// 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<KeyAt<Unpack<S>, K2>>, A4>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4): (s: S1) => Functor<Index<A1>, T3, KeyAt<T3, K4>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4): (s: S1) => KeyAt<A3, K4>

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

export function get<S1, A1, A2, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (s: S1) => A3

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

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

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

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

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>): (s: HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => A5

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

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

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

export function get<K1 extends string, K2 extends string, K3 extends string, S5, A5>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>): (s: HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>) => A5

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

export function get<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Index<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>>

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

export function get<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, A5>

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

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

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

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

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

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

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

export function get<K1 extends string, K2 extends string, K4 extends string, S5, A5>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>): (s: HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>) => A5

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

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

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

export function get<K1 extends string, K2 extends string, S5, A5>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>): (s: HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>) => A5

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

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

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

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

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

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

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

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

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

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

export function get<K1 extends string, K2 extends string, T3, K4 extends string, T5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5>>>>>>(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, K4 extends string, S5, A5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A5>

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

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

export function get<K1 extends string, K2 extends string, T3, T5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>>>(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, S5, A5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A5>

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

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

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

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

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

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

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): <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, T3, S4, A4, A5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A5>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<K1 extends string, K3 extends string, K4 extends string, S5, A5>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): (s: HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>) => A5

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

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

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

export function get<K1 extends string, K3 extends string, S5, A5>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): (s: HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>) => A5

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

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

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

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

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

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

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

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

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

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

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

export function get<K1 extends string, K4 extends string, S5, A5>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): (s: HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>) => A5

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

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

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

export function get<K1 extends string, S5, A5>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>): (s: HasKey<K1, Indexable<Indexable<Indexable<S5>>>>) => A5

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

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

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

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

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

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

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

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

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

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

export function get<K1 extends string, T3, K4 extends string, T5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5>>>>>>(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, K4 extends string, S5, A5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A5>

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

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

export function get<K1 extends string, T3, T5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5>>>>>>(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, S5, A5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A5>

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

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

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

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

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

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

export function get<K1 extends string, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): <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, T3, S4, A4, A5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A5>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<K1 extends string, T2, K3 extends string, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5>>>>>>(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, K4 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

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

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

export function get<K1 extends string, T2, K3 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5>>>>>>(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, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

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

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

export function get<K1 extends string, T2, K3 extends string, T4, T5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5>>>>>>(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, T4, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, A5>>

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

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

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): <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, K3 extends string, S4, A4, A5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<K1 extends string, T2, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): <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, S4, A4, A5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

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

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

export function get<K1 extends string, T2, T3, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5>>>>>>(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, K4 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A5>>

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

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

export function get<K1 extends string, T2, T3, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5>>>>>>(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, S5, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A5>>

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

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

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

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

export function get<K1 extends string, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): <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>>>, KeyAt<A4, K5>>>

export function get<K1 extends string, T2, T3, S4, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): <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>>>, Index<A4>>>

export function get<K1 extends string, T2, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): <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, T3, S4, A4, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <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>>>, A5>>

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

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

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): <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 HasKey<K4>, K4 extends string, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

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

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

export function get<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): <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 Indexable, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

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

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

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): <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 extends Collection<T4>, T4, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, A5>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<K2 extends string, K3 extends string, K4 extends string, S5, A5>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>): (s: Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => A5

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

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

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

export function get<K2 extends string, K3 extends string, S5, A5>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>): (s: Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>) => A5

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

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

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

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

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

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

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

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

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

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

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

export function get<K2 extends string, K4 extends string, S5, A5>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>): (s: Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>) => A5

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

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

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

export function get<K2 extends string, S5, A5>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>): (s: Indexable<HasKey<K2, Indexable<Indexable<S5>>>>) => A5

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

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

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

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

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

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

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

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

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

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

export function get<K2 extends string, T3, K4 extends string, T5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5>>>>>>(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, K4 extends string, S5, A5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A5>

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

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

export function get<K2 extends string, T3, T5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>>>(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, S5, A5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A5>

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

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

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

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

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

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

export function get<K2 extends string, T3, S4, A4 extends Collection<T5>, T5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): <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, T3, S4, A4, A5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A5>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<K3 extends string, K4 extends string, S5, A5>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): (s: Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>) => A5

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

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

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

export function get<K3 extends string, S5, A5>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): (s: Indexable<Indexable<HasKey<K3, Indexable<S5>>>>) => A5

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

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

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

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

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

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

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

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

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

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

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

export function get<K4 extends string, S5, A5>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): (s: Indexable<Indexable<Indexable<HasKey<K4, S5>>>>) => A5

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

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

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

export function get<S5, A5>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>): (s: Indexable<Indexable<Indexable<Indexable<S5>>>>) => A5

export function get<T4, K5 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5): <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, KeyAt<Unpack<Index<Index<Index<S>>>>, K5>>

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

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

export function get<T4, S5, A5>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, A5>

export function get<S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5): (s: Indexable<Indexable<Indexable<S4>>>) => KeyAt<A4, K5>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, KeyAt<T4, K5>>

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

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

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

export function get<S3, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (s: Indexable<Indexable<S3>>) => KeyAt<A4, K5>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<T2, T3, K4 extends string, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5>>>>>>(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, K4 extends string, S5, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A5>>

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

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

export function get<T2, T3, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5>>>>>>(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, S5, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A5>>

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

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

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

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

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

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

export function get<T2, T3, S4, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): <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, T3, S4, A4, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A5>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5): (s: Indexable<S2>) => Functor<Index<A2>, T4, KeyAt<T4, K5>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (s: Indexable<S2>) => Functor<A3, T4, KeyAt<T4, K5>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<T1, K2 extends string, T3, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5>>>>>>(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, K4 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A5>>

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

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

export function get<T1, K2 extends string, T3, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>>>(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, S5, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A5>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<T1, K3 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

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

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

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

export function get<T1, K3 extends string, S5, A5>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

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

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

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

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

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

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

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

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

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

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

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

export function get<T1, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

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

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

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

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

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

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

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

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

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

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

export function get<T1, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, S4, A4, A5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A5>

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

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

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

export function get<T1, T3, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A5>>

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

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

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

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

export function get<T1, T3, T4, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, KeyAt<Unpack<Unpack<Index<Unpack<S>>>>, K5>>>>

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

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

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

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

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

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

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

export function get<T1, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A3, K4>, K5>>

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

export function get<T1, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A3, K4>>

export function get<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A3>, K5>>

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

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

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

export function get<T1, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<T4, K5>>>

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

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

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

export function get<T1, S3, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

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

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

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

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

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

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

export function get<T1, T2, K3 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

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

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

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

export function get<T1, T2, K3 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

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

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

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

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

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

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

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

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

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

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

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

export function get<T1, T2, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<T1, T2, T3, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A5>>>

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

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

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

export function get<T1, T2, T3, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A5>>>

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

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

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

export function get<T1, T2, T3, T4, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, A5>>>>

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

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

export function get<T1, T2, T3, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A4>>>

export function get<T1, T2, T3, S4, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A5>>>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<KeyAt<T3, K4>, K5>>>

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

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<T3, K4>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A5>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<Index<T3>, K5>>>

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

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

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

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, KeyAt<T4, K5>>>

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

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

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

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<A4, K5>>>

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

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

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

export function get<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A3, K4>, K5>>

export function get<T1, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A3, K4>>>

export function get<T1, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A3, K4>>

export function get<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A3>, K5>>

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

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

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

export function get<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<T4, K5>>>

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

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

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

export function get<T1, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

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

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

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

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

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

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5>>>>, K2 extends string, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): (s: S1) => KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>

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

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

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

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5>>>>, K2 extends string, K3 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): (s: S1) => Index<KeyAt<KeyAt<A1, K2>, K3>>

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

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5>>>>, K2 extends string, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable>>>, K2 extends string, K3 extends string, T4>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, Index<T4>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5>>>>, K2 extends string, K3 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => KeyAt<KeyAt<A1, K2>, K3>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, A5>

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

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

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>): (s: S1) => A4

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

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

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

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

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

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

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

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

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

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5>>>>, K2 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable>>>, K2 extends string, T4>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, Index<T4>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5>>>>, K2 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => Index<KeyAt<A1, K2>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, A5>

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

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

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

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

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

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable>>>, K2 extends string, T3, K4 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<KeyAt<T3, K4>>>

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

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

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5>>>>, K2 extends string, T3, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<Index<T3>, K5>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable>>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<Index<T3>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>, K2 extends string, T3, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<T3>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A5>

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

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable>>>, K2 extends string, T3, T4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, Index<T4>>>

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

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

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

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<A4>>

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

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

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5): (s: S1) => KeyAt<KeyAt<A3, K4>, K5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number): (s: S1) => Index<KeyAt<A3, K4>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>): (s: S1) => KeyAt<A3, K4>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5): (s: S1) => KeyAt<Index<A3>, K5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number): (s: S1) => Index<Index<A3>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>): (s: S1) => Index<A3>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number): (s: S1) => Functor<A3, T4, Index<T4>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => A3

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<A3, T4, A5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number): (s: S1) => Index<A4>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (s: S1) => A4

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5>>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5): (s: S1) => KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number): (s: S1) => Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5>>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): (s: S1) => KeyAt<KeyAt<Index<A1>, K3>, K4>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5>>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5): (s: S1) => KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable>>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number): (s: S1) => Index<Index<KeyAt<Index<A1>, K3>>>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5>>>>, K3 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>): (s: S1) => Index<KeyAt<Index<A1>, K3>>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5>>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable>>>, K3 extends string, T4>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, Index<T4>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5>>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => KeyAt<Index<A1>, K3>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, A5>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number): (s: S1) => Index<A4>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>): (s: S1) => A4

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5>>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5): (s: S1) => KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable>>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number): (s: S1) => Index<KeyAt<Index<Index<A1>>, K4>>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5>>>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>): (s: S1) => KeyAt<Index<Index<A1>>, K4>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5>>>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5): (s: S1) => KeyAt<Index<Index<Index<A1>>>, K5>

export function get<S1, A1 extends Indexable<Indexable<Indexable<Indexable>>>>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number): (s: S1) => Index<Index<Index<Index<A1>>>>

export function get<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5>>>>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>): (s: S1) => Index<Index<Index<A1>>>

export function get<S1, A1 extends Indexable<Indexable<Indexable>>, A5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5>>>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<Index<Index<A1>>, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable>>>, T4>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number): (s: S1) => Functor<Index<Index<A1>>, T4, Index<T4>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5>>>>, T4, T5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => Index<Index<A1>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<Index<Index<A1>>, T4, A5>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number): (s: S1) => Index<A4>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>): (s: S1) => A4

export function get<S1, A1 extends Indexable<Indexable>, A4, A5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5>>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): (s: S1) => Functor<Index<A1>, T3, KeyAt<KeyAt<T3, K4>, K5>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number): (s: S1) => Functor<Index<A1>, T3, Index<KeyAt<T3, K4>>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5>>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (s: S1) => Functor<Index<A1>, T3, KeyAt<T3, K4>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (s: S1) => Functor<Index<A1>, T3, A5>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5>>>>, T3, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5): (s: S1) => Functor<Index<A1>, T3, KeyAt<Index<T3>, K5>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable>>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number): (s: S1) => Functor<Index<A1>, T3, Index<Index<T3>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5>>>>, T3, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (s: S1) => Functor<Index<A1>, T3, Index<T3>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (s: S1) => Functor<Index<A1>, T3, A5>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5>>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable>>>, T3, T4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, Index<T4>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5>>>>, T3, T4, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => Index<A1>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, A5>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (s: S1) => Functor<Index<A1>, T3, KeyAt<A4, K5>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (s: S1) => Functor<Index<A1>, T3, Index<A4>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (s: S1) => Functor<Index<A1>, T3, A4>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (s: S1) => Functor<Index<A1>, T3, A5>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5): (s: S1) => KeyAt<KeyAt<A3, K4>, K5>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number): (s: S1) => Index<KeyAt<A3, K4>>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>): (s: S1) => KeyAt<A3, K4>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5): (s: S1) => KeyAt<Index<A3>, K5>

export function get<S1, A1 extends Indexable, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number): (s: S1) => Index<Index<A3>>

export function get<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>): (s: S1) => Index<A3>

export function get<S1, A1 extends Indexable, A3 extends Indexable, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>): (s: S1) => A5

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number): (s: S1) => Functor<A3, T4, Index<T4>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => A3

export function get<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<A3, T4, A5>

export function get<S1, A1 extends Indexable, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends Indexable, A3, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number): (s: S1) => Index<A4>

export function get<S1, A1 extends Indexable, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (s: S1) => A4

export function get<S1, A1 extends Indexable, A3, A4, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (s: S1) => A5

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5>>>>, T2, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<KeyAt<T2, K3>, K4>, K5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable>>>, T2, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): (s: S1) => Functor<A1, T2, Index<KeyAt<KeyAt<T2, K3>, K4>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5>>>>, T2, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<T2, K3>, K4>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5>>>>, T2, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<Index<KeyAt<T2, K3>>, K5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable>>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number): (s: S1) => Functor<A1, T2, Index<Index<KeyAt<T2, K3>>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5>>>>, T2, K3 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, Index<KeyAt<T2, K3>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5>>>>, T2, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable>>>, T2, K3 extends string, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, Index<T4>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5>>>>, T2, K3 extends string, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, KeyAt<T2, K3>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, A5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<A4, K5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number): (s: S1) => Functor<A1, T2, Index<A4>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, A4>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5>>>>, T2, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<Index<T2>, K4>, K5>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable>>>, T2, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number): (s: S1) => Functor<A1, T2, Index<KeyAt<Index<T2>, K4>>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5>>>>, T2, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, KeyAt<Index<T2>, K4>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5>>>>, T2, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<Index<Index<T2>>, K5>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable>>>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number): (s: S1) => Functor<A1, T2, Index<Index<Index<T2>>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5>>>>, T2, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, Index<Index<T2>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5>>>>, T2, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable>>>, T2, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, Index<T4>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5>>>>, T2, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, Index<T2>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, A5>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<A4, K5>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number): (s: S1) => Functor<A1, T2, Index<A4>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, A4>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5>>>>, T2, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<KeyAt<T3, K4>, K5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable>>>, T2, T3, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<KeyAt<T3, K4>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5>>>>, T2, T3, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<T3, K4>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A5>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5>>>>, T2, T3, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<Index<T3>, K5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable>>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<Index<T3>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5>>>>, T2, T3, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<T3>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A5>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5>>>>, T2, T3, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable>>>, T2, T3, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, Index<T4>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5>>>>, T2, T3, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => A1

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, A5>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<A4, K5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<A4>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A4>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A5>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<A3, K4>, K5>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number): (s: S1) => Functor<A1, T2, Index<KeyAt<A3, K4>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, KeyAt<A3, K4>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<Index<A3>, K5>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number): (s: S1) => Functor<A1, T2, Index<Index<A3>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, Index<A3>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<A1, T2, Functor<A3, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number): (s: S1) => Functor<A1, T2, Functor<A3, T4, Index<T4>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, A3>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<A1, T2, Functor<A3, T4, A5>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5): (s: S1) => Functor<A1, T2, KeyAt<A4, K5>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number): (s: S1) => Functor<A1, T2, Index<A4>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (s: S1) => Functor<A1, T2, A4>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5): (s: S1) => KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number): (s: S1) => Index<KeyAt<KeyAt<A2, K3>, K4>>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (s: S1) => KeyAt<KeyAt<A2, K3>, K4>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (s: S1) => A5

export function get<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5): (s: S1) => KeyAt<Index<KeyAt<A2, K3>>, K5>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number): (s: S1) => Index<Index<KeyAt<A2, K3>>>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>): (s: S1) => Index<KeyAt<A2, K3>>

export function get<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (s: S1) => A5

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<KeyAt<A2, K3>, T4, KeyAt<T4, K5>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number): (s: S1) => Functor<KeyAt<A2, K3>, T4, Index<T4>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => KeyAt<A2, K3>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<KeyAt<A2, K3>, T4, A5>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (s: S1) => Index<A4>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (s: S1) => A4

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (s: S1) => A5

export function get<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5): (s: S1) => KeyAt<KeyAt<Index<A2>, K4>, K5>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number): (s: S1) => Index<KeyAt<Index<A2>, K4>>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>): (s: S1) => KeyAt<Index<A2>, K4>

export function get<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (s: S1) => A5

export function get<S1, A1, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5): (s: S1) => KeyAt<Index<Index<A2>>, K5>

export function get<S1, A1, A2 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number): (s: S1) => Index<Index<Index<A2>>>

export function get<S1, A1, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>): (s: S1) => Index<Index<A2>>

export function get<S1, A1, A2 extends Indexable<Indexable>, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (s: S1) => A5

export function get<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<Index<A2>, T4, KeyAt<T4, K5>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number): (s: S1) => Functor<Index<A2>, T4, Index<T4>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => Index<A2>

export function get<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<Index<A2>, T4, A5>

export function get<S1, A1, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1, A2 extends Indexable, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (s: S1) => Index<A4>

export function get<S1, A1, A2 extends Indexable, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (s: S1) => A4

export function get<S1, A1, A2 extends Indexable, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (s: S1) => A5

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (s: S1) => Functor<A2, T3, KeyAt<KeyAt<T3, K4>, K5>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number): (s: S1) => Functor<A2, T3, Index<KeyAt<T3, K4>>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (s: S1) => Functor<A2, T3, KeyAt<T3, K4>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (s: S1) => Functor<A2, T3, A5>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5): (s: S1) => Functor<A2, T3, KeyAt<Index<T3>, K5>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number): (s: S1) => Functor<A2, T3, Index<Index<T3>>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (s: S1) => Functor<A2, T3, Index<T3>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (s: S1) => Functor<A2, T3, A5>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<A2, T3, Functor<T3, T4, KeyAt<T4, K5>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (s: S1) => Functor<A2, T3, Functor<T3, T4, Index<T4>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => A2

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<A2, T3, Functor<T3, T4, A5>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (s: S1) => Functor<A2, T3, KeyAt<A4, K5>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (s: S1) => Functor<A2, T3, Index<A4>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (s: S1) => Functor<A2, T3, A4>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (s: S1) => Functor<A2, T3, A5>

export function get<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (s: S1) => KeyAt<KeyAt<A3, K4>, K5>

export function get<S1, A1, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (s: S1) => Index<KeyAt<A3, K4>>

export function get<S1, A1, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (s: S1) => KeyAt<A3, K4>

export function get<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (s: S1) => A5

export function get<S1, A1, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (s: S1) => KeyAt<Index<A3>, K5>

export function get<S1, A1, A2, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (s: S1) => Index<Index<A3>>

export function get<S1, A1, A2, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (s: S1) => Index<A3>

export function get<S1, A1, A2, A3 extends Indexable, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (s: S1) => A5

export function get<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (s: S1) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<S1, A1, A2, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (s: S1) => Functor<A3, T4, Index<T4>>

export function get<S1, A1, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (s: S1) => A3

export function get<S1, A1, A2, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (s: S1) => Functor<A3, T4, A5>

export function get<S1, A1, A2, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1, A2, A3, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (s: S1) => Index<A4>

export function get<S1, A1, A2, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (s: S1) => A4

export function get<S1, A1, A2, A3, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (s: S1) => A5

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>, K5>, K6>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>, K5>>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>, K5>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>) => A6

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>>, K6>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Index<Index<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>>>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T6>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Index<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>) => A6

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>>, K6>>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>>>>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, T6>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, K4>>, A6>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (s: HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => Index<A5>

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => A5

export function get<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => A6

export function get<K1 extends string, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, K5>, K6>

export function get<K1 extends string, K2 extends string, K3 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, K5>>

export function get<K1 extends string, K2 extends string, K3 extends string, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, K5>

export function get<K1 extends string, K2 extends string, K3 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>) => A6

export function get<K1 extends string, K2 extends string, K3 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, K6>

export function get<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Index<Index<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>>

export function get<K1 extends string, K2 extends string, K3 extends string, T6>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Index<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>

export function get<K1 extends string, K2 extends string, K3 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>) => A6

export function get<K1 extends string, K2 extends string, K3 extends string, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, KeyAt<Unpack<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, K6>>

export function get<K1 extends string, K2 extends string, K3 extends string, T5>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, Index<Unpack<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>>>

export function get<K1 extends string, K2 extends string, K3 extends string, T5, T6>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>

export function get<K1 extends string, K2 extends string, K3 extends string, T5, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, A6>

export function get<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (s: HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>) => Index<A5>

export function get<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>) => A5

export function get<K1 extends string, K2 extends string, K3 extends string, S5, A5, A6>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>) => A6

export function get<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, K5>, K6>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Index<KeyAt<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, K5>>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, KeyAt<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, K5>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, A6>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, KeyAt<Index<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, K6>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Index<Index<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Index<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, A6>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, K6>>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, T5>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, Index<Unpack<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>>>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, T5, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, T5, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>>, A6>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, KeyAt<A5, K6>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, Index<A5>>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, A5>

export function get<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>, Unpack<KeyAt<KeyAt<KeyAt<S, K1>, K2>, K3>>, A6>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => KeyAt<A4, K5>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => A6

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => Index<Index<A4>>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => Index<A4>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => A6

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => A4

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => Functor<A4, T5, A6>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => Index<A5>

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => A5

export function get<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, HasKey<K3, S4>>>) => A6

export function get<K1 extends string, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>, K5>, K6>

export function get<K1 extends string, K2 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>, K5>>

export function get<K1 extends string, K2 extends string, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>, K5>

export function get<K1 extends string, K2 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (s: HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>) => A6

export function get<K1 extends string, K2 extends string, K4 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>>, K6>

export function get<K1 extends string, K2 extends string, K4 extends string>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Index<Index<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>>>

export function get<K1 extends string, K2 extends string, K4 extends string, T6>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Index<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>>

export function get<K1 extends string, K2 extends string, K4 extends string, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (s: HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>) => A6

export function get<K1 extends string, K2 extends string, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>>, KeyAt<Unpack<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>>, K6>>

export function get<K1 extends string, K2 extends string, K4 extends string, T5>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>>, Index<Unpack<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>>>>

export function get<K1 extends string, K2 extends string, K4 extends string, T5, T6>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>

export function get<K1 extends string, K2 extends string, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<KeyAt<S, K1>, K2>>, K4>>, A6>

export function get<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (s: HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>) => Index<A5>

export function get<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>) => A5

export function get<K1 extends string, K2 extends string, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>) => A6

export function get<K1 extends string, K2 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>, K5>, K6>

export function get<K1 extends string, K2 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>, K5>>

export function get<K1 extends string, K2 extends string, K5 extends string, T6>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>, K5>

export function get<K1 extends string, K2 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (s: HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>) => A6

export function get<K1 extends string, K2 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>>, K6>

export function get<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number, i4: number, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Index<Index<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>>>

export function get<K1 extends string, K2 extends string, T6>(k1: K1, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Index<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>>

export function get<K1 extends string, K2 extends string, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (s: HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>) => A6

export function get<K1 extends string, K2 extends string, T5, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>>, KeyAt<Unpack<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>>, K6>>

export function get<K1 extends string, K2 extends string, T5>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>>, Index<Unpack<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>>>>

export function get<K1 extends string, K2 extends string, T5, T6>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<Index<KeyAt<KeyAt<S, K1>, K2>>>

export function get<K1 extends string, K2 extends string, T5, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Index<Index<KeyAt<KeyAt<S, K1>, K2>>>>, A6>

export function get<K1 extends string, K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (s: HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>) => Index<A5>

export function get<K1 extends string, K2 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>) => A5

export function get<K1 extends string, K2 extends string, S5, A5, A6>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>) => A6

export function get<K1 extends string, K2 extends string, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, KeyAt<KeyAt<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, K5>, K6>>

export function get<K1 extends string, K2 extends string, T4, K5 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Index<KeyAt<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, K5>>>

export function get<K1 extends string, K2 extends string, T4, K5 extends string, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, KeyAt<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, K5>>

export function get<K1 extends string, K2 extends string, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, A6>

export function get<K1 extends string, K2 extends string, T4, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, KeyAt<Index<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>>, K6>>

export function get<K1 extends string, K2 extends string, T4>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Index<Index<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>>>>

export function get<K1 extends string, K2 extends string, T4, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Index<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>>>

export function get<K1 extends string, K2 extends string, T4, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, A6>

export function get<K1 extends string, K2 extends string, T4, T5, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Functor<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>>, KeyAt<Unpack<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>>, K6>>>

export function get<K1 extends string, K2 extends string, T4, T5>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Functor<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>>, Index<Unpack<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>>>>>

export function get<K1 extends string, K2 extends string, T4, T5, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<KeyAt<KeyAt<S, K1>, K2>>

export function get<K1 extends string, K2 extends string, T4, T5, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Functor<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>>, A6>>

export function get<K1 extends string, K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, KeyAt<A5, K6>>

export function get<K1 extends string, K2 extends string, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, Index<A5>>

export function get<K1 extends string, K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, A5>

export function get<K1 extends string, K2 extends string, T4, S5, A5, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Index<KeyAt<KeyAt<S, K1>, K2>>>, A6>

export function get<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => KeyAt<A4, K5>

export function get<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => A6

export function get<K1 extends string, K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, K2 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => Index<Index<A4>>

export function get<K1 extends string, K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => Index<A4>

export function get<K1 extends string, K2 extends string, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => A6

export function get<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => A4

export function get<K1 extends string, K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => Functor<A4, T5, A6>

export function get<K1 extends string, K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => Index<A5>

export function get<K1 extends string, K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => A5

export function get<K1 extends string, K2 extends string, S4, A4, A5, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, Indexable<S4>>>) => A6

export function get<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<KeyAt<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>, K5>, K6>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<KeyAt<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>, K5>>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>, K5>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<Index<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>, K6>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<Index<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>, K6>>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, T5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>, Index<Unpack<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>>>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(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, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<KeyAt<S, K1>, K2>>, K4>>, A6>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<A5, K6>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<A5>>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A5>

export function get<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, T3, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<KeyAt<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, K5>, K6>>

export function get<K1 extends string, K2 extends string, T3, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<KeyAt<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, K5>>>

export function get<K1 extends string, K2 extends string, T3, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, K5>>

export function get<K1 extends string, K2 extends string, T3, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, T3, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<Index<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, K6>>

export function get<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<Index<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>>>

export function get<K1 extends string, K2 extends string, T3, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>>

export function get<K1 extends string, K2 extends string, T3, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, T3, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, KeyAt<Unpack<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, K6>>>

export function get<K1 extends string, K2 extends string, T3, T5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, Index<Unpack<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>>>>

export function get<K1 extends string, K2 extends string, T3, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(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, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Index<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, A6>>

export function get<K1 extends string, K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<A5, K6>>

export function get<K1 extends string, K2 extends string, T3, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<A5>>

export function get<K1 extends string, K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A5>

export function get<K1 extends string, K2 extends string, T3, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, T3, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, KeyAt<KeyAt<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, K5>, K6>>>

export function get<K1 extends string, K2 extends string, T3, T4, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Index<KeyAt<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, K5>>>>

export function get<K1 extends string, K2 extends string, T3, T4, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, KeyAt<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, K5>>>

export function get<K1 extends string, K2 extends string, T3, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, A6>>

export function get<K1 extends string, K2 extends string, T3, T4, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, KeyAt<Index<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, K6>>>

export function get<K1 extends string, K2 extends string, T3, T4>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Index<Index<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>>>>

export function get<K1 extends string, K2 extends string, T3, T4, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Index<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>>>

export function get<K1 extends string, K2 extends string, T3, T4, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, A6>>

export function get<K1 extends string, K2 extends string, T3, T4, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Functor<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, KeyAt<Unpack<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, K6>>>>

export function get<K1 extends string, K2 extends string, T3, T4, T5>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Functor<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, Index<Unpack<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>>>>>

export function get<K1 extends string, K2 extends string, T3, T4, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<S, K1>, K2>

export function get<K1 extends string, K2 extends string, T3, T4, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Functor<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Unpack<Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>>, A6>>>

export function get<K1 extends string, K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, KeyAt<A5, K6>>>

export function get<K1 extends string, K2 extends string, T3, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, Index<A5>>>

export function get<K1 extends string, K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, A5>>

export function get<K1 extends string, K2 extends string, T3, T4, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<Unpack<KeyAt<KeyAt<S, K1>, K2>>, Unpack<Unpack<KeyAt<KeyAt<S, K1>, K2>>>, A6>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<KeyAt<A4, K5>>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<A4, K5>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<Index<A4>, K6>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<Index<A4>>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<A4>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<A4, T5, Index<T5>>>

export function get<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <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, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Functor<A4, T5, A6>>

export function get<K1 extends string, K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, KeyAt<A5, K6>>

export function get<K1 extends string, K2 extends string, T3, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, Index<A5>>

export function get<K1 extends string, K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A5>

export function get<K1 extends string, K2 extends string, T3, S4, A4, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<KeyAt<S, K1>, K2>, Unpack<KeyAt<KeyAt<S, K1>, K2>>, A6>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<KeyAt<A3, K4>, K5>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<Index<KeyAt<A3, K4>>>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => Index<KeyAt<A3, K4>>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<A3, K4>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<A5>

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => A5

export function get<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<KeyAt<Index<A3>, K5>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<Index<A3>, K5>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<Index<Index<A3>>, K6>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<Index<Index<A3>>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => Index<Index<A3>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<Index<A3>, T5, Index<T5>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => Index<A3>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<Index<A3>, T5, A6>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<A5>

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => A5

export function get<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, A6>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, Index<Index<T4>>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, Index<T4>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, A6>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => A3

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, Index<A5>>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, A5>

export function get<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A3, T4, A6>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<A4, K5>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<Index<A4>>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => Index<A4>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => A4

export function get<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => Functor<A4, T5, A6>

export function get<K1 extends string, K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, HasKey<K2, S3>>) => KeyAt<A5, K6>

export function get<K1 extends string, K2 extends string, S3, A3, A4, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, HasKey<K2, S3>>) => Index<A5>

export function get<K1 extends string, K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, HasKey<K2, S3>>) => A5

export function get<K1 extends string, K2 extends string, S3, A3, A4, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, HasKey<K2, S3>>) => A6

export function get<K1 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>, K5>, K6>

export function get<K1 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>, K5>>

export function get<K1 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>, K5>

export function get<K1 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (s: HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>) => A6

export function get<K1 extends string, K3 extends string, K4 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>>, K6>

export function get<K1 extends string, K3 extends string, K4 extends string>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Index<Index<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>>>

export function get<K1 extends string, K3 extends string, K4 extends string, T6>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Index<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>>

export function get<K1 extends string, K3 extends string, K4 extends string, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (s: HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>) => A6

export function get<K1 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>>, K6>>

export function get<K1 extends string, K3 extends string, K4 extends string, T5>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>>>>

export function get<K1 extends string, K3 extends string, K4 extends string, T5, T6>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>

export function get<K1 extends string, K3 extends string, K4 extends string, T5, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<KeyAt<S, K1>>, K3>, K4>>, A6>

export function get<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (s: HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (s: HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>) => Index<A5>

export function get<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>) => A5

export function get<K1 extends string, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>) => A6

export function get<K1 extends string, K3 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>, K5>, K6>

export function get<K1 extends string, K3 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>, K5>>

export function get<K1 extends string, K3 extends string, K5 extends string, T6>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>, K5>

export function get<K1 extends string, K3 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (s: HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>) => A6

export function get<K1 extends string, K3 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, i5: number, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>>, K6>

export function get<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3, i4: number, i5: number, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Index<Index<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>>>

export function get<K1 extends string, K3 extends string, T6>(k1: K1, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Index<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>>

export function get<K1 extends string, K3 extends string, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (s: HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>) => A6

export function get<K1 extends string, K3 extends string, T5, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>, Unpack<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>>, KeyAt<Unpack<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>>, K6>>

export function get<K1 extends string, K3 extends string, T5>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>, Unpack<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>>, Index<Unpack<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>>>>

export function get<K1 extends string, K3 extends string, T5, T6>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<KeyAt<Index<KeyAt<S, K1>>, K3>>

export function get<K1 extends string, K3 extends string, T5, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>, Unpack<Index<KeyAt<Index<KeyAt<S, K1>>, K3>>>, A6>

export function get<K1 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (s: HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K3 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (s: HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>) => Index<A5>

export function get<K1 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>) => A5

export function get<K1 extends string, K3 extends string, S5, A5, A6>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>) => A6

export function get<K1 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, K5>, K6>>

export function get<K1 extends string, K3 extends string, T4, K5 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Index<KeyAt<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, K5>>>

export function get<K1 extends string, K3 extends string, T4, K5 extends string, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, KeyAt<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, K5>>

export function get<K1 extends string, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, A6>

export function get<K1 extends string, K3 extends string, T4, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, KeyAt<Index<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>>, K6>>

export function get<K1 extends string, K3 extends string, T4>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Index<Index<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>>>>

export function get<K1 extends string, K3 extends string, T4, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Index<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>>>

export function get<K1 extends string, K3 extends string, T4, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, A6>

export function get<K1 extends string, K3 extends string, T4, T5, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Functor<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Unpack<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>>, K6>>>

export function get<K1 extends string, K3 extends string, T4, T5>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Functor<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Unpack<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>>, Index<Unpack<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>>>>>

export function get<K1 extends string, K3 extends string, T4, T5, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<Index<KeyAt<S, K1>>, K3>

export function get<K1 extends string, K3 extends string, T4, T5, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Functor<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Unpack<Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>>, A6>>

export function get<K1 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, KeyAt<A5, K6>>

export function get<K1 extends string, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, Index<A5>>

export function get<K1 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, A5>

export function get<K1 extends string, K3 extends string, T4, S5, A5, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Index<KeyAt<S, K1>>, K3>>, A6>

export function get<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => KeyAt<A4, K5>

export function get<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => A6

export function get<K1 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => Index<Index<A4>>

export function get<K1 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => Index<A4>

export function get<K1 extends string, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => A6

export function get<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => A4

export function get<K1 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => Functor<A4, T5, A6>

export function get<K1 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => Index<A5>

export function get<K1 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => A5

export function get<K1 extends string, K3 extends string, S4, A4, A5, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<HasKey<K3, S4>>>) => A6

export function get<K1 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>, K5>, K6>

export function get<K1 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>, K5>>

export function get<K1 extends string, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>, K5>

export function get<K1 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (s: HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>) => A6

export function get<K1 extends string, K4 extends string, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>>, K6>

export function get<K1 extends string, K4 extends string>(k1: K1, i2: number, i3: number, k4: K4, i5: number, i6: number): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Index<Index<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>>>

export function get<K1 extends string, K4 extends string, T6>(k1: K1, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Index<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>>

export function get<K1 extends string, K4 extends string, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (s: HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>) => A6

export function get<K1 extends string, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>>, KeyAt<Unpack<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>>, K6>>

export function get<K1 extends string, K4 extends string, T5>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>>, Index<Unpack<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>>>>

export function get<K1 extends string, K4 extends string, T5, T6>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<Index<Index<KeyAt<S, K1>>>, K4>

export function get<K1 extends string, K4 extends string, T5, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Index<Index<KeyAt<S, K1>>>, K4>>, A6>

export function get<K1 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (s: HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>) => KeyAt<A5, K6>

export function get<K1 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (s: HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>) => Index<A5>

export function get<K1 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>) => A5

export function get<K1 extends string, K4 extends string, S5, A5, A6>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>) => A6

export function get<K1 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<Index<Index<Index<KeyAt<S, K1>>>>, K5>, K6>

export function get<K1 extends string, K5 extends string>(k1: K1, i2: number, i3: number, i4: number, k5: K5, i6: number): <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<Index<Index<Index<KeyAt<S, K1>>>>, K5>>

export function get<K1 extends string, K5 extends string, T6>(k1: K1, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<Index<Index<Index<KeyAt<S, K1>>>>, K5>

export function get<K1 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (s: HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>) => A6

export function get<K1 extends string, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, i5: number, k6: K6): <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<Index<Index<Index<KeyAt<S, K1>>>>>, K6>

export function get<K1 extends string>(k1: K1, i2: number, i3: number, i4: number, i5: number, i6: number): <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Index<Index<Index<Index<Index<KeyAt<S, K1>>>>>>

export function get<K1 extends string, T6>(k1: K1, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Index<Index<Index<Index<KeyAt<S, K1>>>>>

export function get<K1 extends string, S6, A6>(k1: K1, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (s: HasKey<K1, Indexable<Indexable<Indexable<Indexable<S6>>>>>) => A6

export function get<K1 extends string, T5, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<Index<KeyAt<S, K1>>>>, Unpack<Index<Index<Index<KeyAt<S, K1>>>>>, KeyAt<Unpack<Index<Index<Index<KeyAt<S, K1>>>>>, K6>>

export function get<K1 extends string, T5>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<Index<KeyAt<S, K1>>>>, Unpack<Index<Index<Index<KeyAt<S, K1>>>>>, Index<Unpack<Index<Index<Index<KeyAt<S, K1>>>>>>>

export function get<K1 extends string, T5, T6>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<Index<Index<KeyAt<S, K1>>>>

export function get<K1 extends string, T5, S6, A6>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<Index<KeyAt<S, K1>>>>, Unpack<Index<Index<Index<KeyAt<S, K1>>>>>, A6>

export function get<K1 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (s: HasKey<K1, Indexable<Indexable<Indexable<S5>>>>) => KeyAt<A5, K6>

export function get<K1 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (s: HasKey<K1, Indexable<Indexable<Indexable<S5>>>>) => Index<A5>

export function get<K1 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<Indexable<Indexable<S5>>>>) => A5

export function get<K1 extends string, S5, A5, A6>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<Indexable<Indexable<S5>>>>) => A6

export function get<K1 extends string, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, KeyAt<KeyAt<Unpack<Index<Index<KeyAt<S, K1>>>>, K5>, K6>>

export function get<K1 extends string, T4, K5 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, Index<KeyAt<Unpack<Index<Index<KeyAt<S, K1>>>>, K5>>>

export function get<K1 extends string, T4, K5 extends string, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, KeyAt<Unpack<Index<Index<KeyAt<S, K1>>>>, K5>>

export function get<K1 extends string, T4, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, A6>

export function get<K1 extends string, T4, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, KeyAt<Index<Unpack<Index<Index<KeyAt<S, K1>>>>>, K6>>

export function get<K1 extends string, T4>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, Index<Index<Unpack<Index<Index<KeyAt<S, K1>>>>>>>

export function get<K1 extends string, T4, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, Index<Unpack<Index<Index<KeyAt<S, K1>>>>>>

export function get<K1 extends string, T4, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, A6>

export function get<K1 extends string, T4, T5, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, Functor<Unpack<Index<Index<KeyAt<S, K1>>>>, Unpack<Unpack<Index<Index<KeyAt<S, K1>>>>>, KeyAt<Unpack<Unpack<Index<Index<KeyAt<S, K1>>>>>, K6>>>

export function get<K1 extends string, T4, T5>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, Functor<Unpack<Index<Index<KeyAt<S, K1>>>>, Unpack<Unpack<Index<Index<KeyAt<S, K1>>>>>, Index<Unpack<Unpack<Index<Index<KeyAt<S, K1>>>>>>>>

export function get<K1 extends string, T4, T5, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<Index<KeyAt<S, K1>>>

export function get<K1 extends string, T4, T5, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, Functor<Unpack<Index<Index<KeyAt<S, K1>>>>, Unpack<Unpack<Index<Index<KeyAt<S, K1>>>>>, A6>>

export function get<K1 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, KeyAt<A5, K6>>

export function get<K1 extends string, T4, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, Index<A5>>

export function get<K1 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, A5>

export function get<K1 extends string, T4, S5, A5, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<KeyAt<S, K1>>>, Unpack<Index<Index<KeyAt<S, K1>>>>, A6>

export function get<K1 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (s: HasKey<K1, Indexable<Indexable<S4>>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (s: HasKey<K1, Indexable<Indexable<S4>>>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => KeyAt<A4, K5>

export function get<K1 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => A6

export function get<K1 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (s: HasKey<K1, Indexable<Indexable<S4>>>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (s: HasKey<K1, Indexable<Indexable<S4>>>) => Index<Index<A4>>

export function get<K1 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => Index<A4>

export function get<K1 extends string, S4, A4 extends Indexable, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => A6

export function get<K1 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, Indexable<Indexable<S4>>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, Indexable<Indexable<S4>>>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => A4

export function get<K1 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => Functor<A4, T5, A6>

export function get<K1 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, Indexable<Indexable<S4>>>) => KeyAt<A5, K6>

export function get<K1 extends string, S4, A4, A5 extends Indexable>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, Indexable<Indexable<S4>>>) => Index<A5>

export function get<K1 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => A5

export function get<K1 extends string, S4, A4, A5, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<Indexable<S4>>>) => A6

export function get<K1 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<KeyAt<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>, K5>, K6>>

export function get<K1 extends string, T3, K4 extends string, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<KeyAt<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>, K5>>>

export function get<K1 extends string, T3, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>, K5>>

export function get<K1 extends string, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, T3, K4 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<Index<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>, K6>>

export function get<K1 extends string, T3, K4 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<Index<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>>>

export function get<K1 extends string, T3, K4 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>>

export function get<K1 extends string, T3, K4 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, T3, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>, K6>>>

export function get<K1 extends string, T3, K4 extends string, T5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>, Index<Unpack<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>>>>

export function get<K1 extends string, T3, K4 extends string, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(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, K4 extends string, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Unpack<Index<KeyAt<S, K1>>>, K4>>, A6>>

export function get<K1 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<A5, K6>>

export function get<K1 extends string, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<A5>>

export function get<K1 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A5>

export function get<K1 extends string, T3, K4 extends string, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, T3, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<KeyAt<Index<Unpack<Index<KeyAt<S, K1>>>>, K5>, K6>>

export function get<K1 extends string, T3, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<KeyAt<Index<Unpack<Index<KeyAt<S, K1>>>>, K5>>>

export function get<K1 extends string, T3, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<Index<Unpack<Index<KeyAt<S, K1>>>>, K5>>

export function get<K1 extends string, T3, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, T3, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<Index<Index<Unpack<Index<KeyAt<S, K1>>>>>, K6>>

export function get<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<Index<Index<Unpack<Index<KeyAt<S, K1>>>>>>>

export function get<K1 extends string, T3, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<Index<Unpack<Index<KeyAt<S, K1>>>>>>

export function get<K1 extends string, T3, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, T3, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Index<Unpack<Index<KeyAt<S, K1>>>>, Unpack<Index<Unpack<Index<KeyAt<S, K1>>>>>, KeyAt<Unpack<Index<Unpack<Index<KeyAt<S, K1>>>>>, K6>>>

export function get<K1 extends string, T3, T5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Index<Unpack<Index<KeyAt<S, K1>>>>, Unpack<Index<Unpack<Index<KeyAt<S, K1>>>>>, Index<Unpack<Index<Unpack<Index<KeyAt<S, K1>>>>>>>>

export function get<K1 extends string, T3, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(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, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Index<Unpack<Index<KeyAt<S, K1>>>>, Unpack<Index<Unpack<Index<KeyAt<S, K1>>>>>, A6>>

export function get<K1 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<A5, K6>>

export function get<K1 extends string, T3, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<A5>>

export function get<K1 extends string, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A5>

export function get<K1 extends string, T3, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, T3, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, KeyAt<KeyAt<Unpack<Unpack<Index<KeyAt<S, K1>>>>, K5>, K6>>>

export function get<K1 extends string, T3, T4, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, Index<KeyAt<Unpack<Unpack<Index<KeyAt<S, K1>>>>, K5>>>>

export function get<K1 extends string, T3, T4, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, KeyAt<Unpack<Unpack<Index<KeyAt<S, K1>>>>, K5>>>

export function get<K1 extends string, T3, T4, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, A6>>

export function get<K1 extends string, T3, T4, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, KeyAt<Index<Unpack<Unpack<Index<KeyAt<S, K1>>>>>, K6>>>

export function get<K1 extends string, T3, T4>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, Index<Index<Unpack<Unpack<Index<KeyAt<S, K1>>>>>>>>

export function get<K1 extends string, T3, T4, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, Index<Unpack<Unpack<Index<KeyAt<S, K1>>>>>>>

export function get<K1 extends string, T3, T4, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, A6>>

export function get<K1 extends string, T3, T4, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, Functor<Unpack<Unpack<Index<KeyAt<S, K1>>>>, Unpack<Unpack<Unpack<Index<KeyAt<S, K1>>>>>, KeyAt<Unpack<Unpack<Unpack<Index<KeyAt<S, K1>>>>>, K6>>>>

export function get<K1 extends string, T3, T4, T5>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, Functor<Unpack<Unpack<Index<KeyAt<S, K1>>>>, Unpack<Unpack<Unpack<Index<KeyAt<S, K1>>>>>, Index<Unpack<Unpack<Unpack<Index<KeyAt<S, K1>>>>>>>>>

export function get<K1 extends string, T3, T4, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<KeyAt<S, K1>>

export function get<K1 extends string, T3, T4, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, Functor<Unpack<Unpack<Index<KeyAt<S, K1>>>>, Unpack<Unpack<Unpack<Index<KeyAt<S, K1>>>>>, A6>>>

export function get<K1 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, KeyAt<A5, K6>>>

export function get<K1 extends string, T3, T4, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, Index<A5>>>

export function get<K1 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, A5>>

export function get<K1 extends string, T3, T4, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<Unpack<Index<KeyAt<S, K1>>>, Unpack<Unpack<Index<KeyAt<S, K1>>>>, A6>>

export function get<K1 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<K1 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<KeyAt<A4, K5>>>

export function get<K1 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<A4, K5>>

export function get<K1 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<Index<A4>, K6>>

export function get<K1 extends string, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<Index<A4>>>

export function get<K1 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<A4>>

export function get<K1 extends string, T3, S4, A4 extends Indexable, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<A4, T5, Index<T5>>>

export function get<K1 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <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, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Functor<A4, T5, A6>>

export function get<K1 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, KeyAt<A5, K6>>

export function get<K1 extends string, T3, S4, A4, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, Index<A5>>

export function get<K1 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A5>

export function get<K1 extends string, T3, S4, A4, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<KeyAt<S, K1>>, Unpack<Index<KeyAt<S, K1>>>, A6>

export function get<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => KeyAt<KeyAt<A3, K4>, K5>

export function get<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<K1 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<Index<KeyAt<A3, K4>>>

export function get<K1 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => Index<KeyAt<A3, K4>>

export function get<K1 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, Indexable<S3>>) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: HasKey<K1, Indexable<S3>>) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => KeyAt<A3, K4>

export function get<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, Indexable<S3>>) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<A5, K6>

export function get<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<A5>

export function get<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => A5

export function get<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<K1 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<KeyAt<Index<A3>, K5>>

export function get<K1 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => KeyAt<Index<A3>, K5>

export function get<K1 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<Index<Index<A3>>, K6>

export function get<K1 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<Index<Index<A3>>>

export function get<K1 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => Index<Index<A3>>

export function get<K1 extends string, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, Indexable<S3>>) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: HasKey<K1, Indexable<S3>>) => Functor<Index<A3>, T5, Index<T5>>

export function get<K1 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => Index<A3>

export function get<K1 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, Indexable<S3>>) => Functor<Index<A3>, T5, A6>

export function get<K1 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<A5, K6>

export function get<K1 extends string, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<A5>

export function get<K1 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => A5

export function get<K1 extends string, S3, A3 extends Indexable, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, A6>

export function get<K1 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<K1 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, Index<Index<T4>>>

export function get<K1 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, Index<T4>>

export function get<K1 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, A6>

export function get<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => A3

export function get<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, Index<A5>>

export function get<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, A5>

export function get<K1 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<S3>>) => Functor<A3, T4, A6>

export function get<K1 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => KeyAt<A4, K5>

export function get<K1 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<Index<A4>>

export function get<K1 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => Index<A4>

export function get<K1 extends string, S3, A3, A4 extends Indexable, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, Indexable<S3>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, Indexable<S3>>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => A4

export function get<K1 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, Indexable<S3>>) => Functor<A4, T5, A6>

export function get<K1 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, Indexable<S3>>) => KeyAt<A5, K6>

export function get<K1 extends string, S3, A3, A4, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, Indexable<S3>>) => Index<A5>

export function get<K1 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, Indexable<S3>>) => A5

export function get<K1 extends string, S3, A3, A4, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, Indexable<S3>>) => A6

export function get<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>, K5>, K6>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>, K5>>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>, K5>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>, K6>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>, K6>>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>>>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(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, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<KeyAt<S, K1>>, K3>, K4>>, A6>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K3 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, K5>, K6>>

export function get<K1 extends string, T2, K3 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, K5>>>

export function get<K1 extends string, T2, K3 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, K5>>

export function get<K1 extends string, T2, K3 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K3 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, K6>>

export function get<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>>>

export function get<K1 extends string, T2, K3 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>>

export function get<K1 extends string, T2, K3 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K3 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Unpack<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, KeyAt<Unpack<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, K6>>>

export function get<K1 extends string, T2, K3 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Unpack<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, Index<Unpack<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>>>>

export function get<K1 extends string, T2, K3 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(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, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Unpack<Index<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, A6>>

export function get<K1 extends string, T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, K3 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, K3 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, K5>, K6>>>

export function get<K1 extends string, T2, K3 extends string, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Index<KeyAt<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, K5>>>>

export function get<K1 extends string, T2, K3 extends string, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, KeyAt<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, K5>>>

export function get<K1 extends string, T2, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, A6>>

export function get<K1 extends string, T2, K3 extends string, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, KeyAt<Index<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, K6>>>

export function get<K1 extends string, T2, K3 extends string, T4>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Index<Index<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>>>>

export function get<K1 extends string, T2, K3 extends string, T4, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Index<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>>>

export function get<K1 extends string, T2, K3 extends string, T4, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, A6>>

export function get<K1 extends string, T2, K3 extends string, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Functor<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Unpack<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, K6>>>>

export function get<K1 extends string, T2, K3 extends string, T4, T5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Functor<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Unpack<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, Index<Unpack<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>>>>>

export function get<K1 extends string, T2, K3 extends string, T4, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(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, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Functor<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Unpack<Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>>, A6>>>

export function get<K1 extends string, T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, KeyAt<A5, K6>>>

export function get<K1 extends string, T2, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, Index<A5>>>

export function get<K1 extends string, T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, A5>>

export function get<K1 extends string, T2, K3 extends string, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Unpack<KeyAt<S, K1>>, K3>, Unpack<KeyAt<Unpack<KeyAt<S, K1>>, K3>>, A6>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<A4, K5>>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A4, K5>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<A4>, K6>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<A4>>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A4>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, Index<T5>>>

export function get<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <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, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, A6>>

export function get<K1 extends string, T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, K3 extends string, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>, K5>, K6>>

export function get<K1 extends string, T2, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>, K5>>>

export function get<K1 extends string, T2, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>, K5>>

export function get<K1 extends string, T2, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>, K6>>

export function get<K1 extends string, T2, K4 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>>>

export function get<K1 extends string, T2, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>>

export function get<K1 extends string, T2, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>, KeyAt<Unpack<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>, K6>>>

export function get<K1 extends string, T2, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>, Index<Unpack<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>>>>

export function get<K1 extends string, T2, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>

export function get<K1 extends string, T2, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Index<Unpack<KeyAt<S, K1>>>, K4>>, A6>>

export function get<K1 extends string, T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<Index<Index<Unpack<KeyAt<S, K1>>>>, K5>, K6>>

export function get<K1 extends string, T2, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<Index<Index<Unpack<KeyAt<S, K1>>>>, K5>>>

export function get<K1 extends string, T2, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<Index<Unpack<KeyAt<S, K1>>>>, K5>>

export function get<K1 extends string, T2, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<Index<Index<Unpack<KeyAt<S, K1>>>>>, K6>>

export function get<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<Index<Index<Unpack<KeyAt<S, K1>>>>>>>

export function get<K1 extends string, T2, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<Index<Unpack<KeyAt<S, K1>>>>>>

export function get<K1 extends string, T2, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Index<Unpack<KeyAt<S, K1>>>>, Unpack<Index<Index<Unpack<KeyAt<S, K1>>>>>, KeyAt<Unpack<Index<Index<Unpack<KeyAt<S, K1>>>>>, K6>>>

export function get<K1 extends string, T2, T5>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Index<Unpack<KeyAt<S, K1>>>>, Unpack<Index<Index<Unpack<KeyAt<S, K1>>>>>, Index<Unpack<Index<Index<Unpack<KeyAt<S, K1>>>>>>>>

export function get<K1 extends string, T2, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<Unpack<KeyAt<S, K1>>>>>

export function get<K1 extends string, T2, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Index<Unpack<KeyAt<S, K1>>>>, Unpack<Index<Index<Unpack<KeyAt<S, K1>>>>>, A6>>

export function get<K1 extends string, T2, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, KeyAt<KeyAt<Unpack<Index<Unpack<KeyAt<S, K1>>>>, K5>, K6>>>

export function get<K1 extends string, T2, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, Index<KeyAt<Unpack<Index<Unpack<KeyAt<S, K1>>>>, K5>>>>

export function get<K1 extends string, T2, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, KeyAt<Unpack<Index<Unpack<KeyAt<S, K1>>>>, K5>>>

export function get<K1 extends string, T2, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, A6>>

export function get<K1 extends string, T2, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, KeyAt<Index<Unpack<Index<Unpack<KeyAt<S, K1>>>>>, K6>>>

export function get<K1 extends string, T2, T4>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, Index<Index<Unpack<Index<Unpack<KeyAt<S, K1>>>>>>>>

export function get<K1 extends string, T2, T4, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, Index<Unpack<Index<Unpack<KeyAt<S, K1>>>>>>>

export function get<K1 extends string, T2, T4, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, A6>>

export function get<K1 extends string, T2, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, Functor<Unpack<Index<Unpack<KeyAt<S, K1>>>>, Unpack<Unpack<Index<Unpack<KeyAt<S, K1>>>>>, KeyAt<Unpack<Unpack<Index<Unpack<KeyAt<S, K1>>>>>, K6>>>>

export function get<K1 extends string, T2, T4, T5>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, Functor<Unpack<Index<Unpack<KeyAt<S, K1>>>>, Unpack<Unpack<Index<Unpack<KeyAt<S, K1>>>>>, Index<Unpack<Unpack<Index<Unpack<KeyAt<S, K1>>>>>>>>>

export function get<K1 extends string, T2, T4, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Unpack<KeyAt<S, K1>>>>

export function get<K1 extends string, T2, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, Functor<Unpack<Index<Unpack<KeyAt<S, K1>>>>, Unpack<Unpack<Index<Unpack<KeyAt<S, K1>>>>>, A6>>>

export function get<K1 extends string, T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, KeyAt<A5, K6>>>

export function get<K1 extends string, T2, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, Index<A5>>>

export function get<K1 extends string, T2, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, A5>>

export function get<K1 extends string, T2, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<Unpack<KeyAt<S, K1>>>, Unpack<Index<Unpack<KeyAt<S, K1>>>>, A6>>

export function get<K1 extends string, T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<K1 extends string, T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<A4, K5>>>

export function get<K1 extends string, T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A4, K5>>

export function get<K1 extends string, T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<A4>, K6>>

export function get<K1 extends string, T2, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<A4>>>

export function get<K1 extends string, T2, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A4>>

export function get<K1 extends string, T2, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, T2, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, Index<T5>>>

export function get<K1 extends string, T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <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, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, A6>>

export function get<K1 extends string, T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<KeyAt<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>, K5>, K6>>>

export function get<K1 extends string, T2, T3, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<KeyAt<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>, K5>>>>

export function get<K1 extends string, T2, T3, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>, K5>>>

export function get<K1 extends string, T2, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A6>>

export function get<K1 extends string, T2, T3, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<Index<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>, K6>>>

export function get<K1 extends string, T2, T3, K4 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<Index<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>>>>

export function get<K1 extends string, T2, T3, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>>>

export function get<K1 extends string, T2, T3, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A6>>

export function get<K1 extends string, T2, T3, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>, K6>>>>

export function get<K1 extends string, T2, T3, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>, Index<Unpack<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>>>>>

export function get<K1 extends string, T2, T3, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(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, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>, Unpack<KeyAt<Unpack<Unpack<KeyAt<S, K1>>>, K4>>, A6>>>

export function get<K1 extends string, T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<A5, K6>>>

export function get<K1 extends string, T2, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<A5>>>

export function get<K1 extends string, T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A5>>

export function get<K1 extends string, T2, T3, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A6>>

export function get<K1 extends string, T2, T3, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<KeyAt<Index<Unpack<Unpack<KeyAt<S, K1>>>>, K5>, K6>>>

export function get<K1 extends string, T2, T3, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<KeyAt<Index<Unpack<Unpack<KeyAt<S, K1>>>>, K5>>>>

export function get<K1 extends string, T2, T3, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<Index<Unpack<Unpack<KeyAt<S, K1>>>>, K5>>>

export function get<K1 extends string, T2, T3, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A6>>

export function get<K1 extends string, T2, T3, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<Index<Index<Unpack<Unpack<KeyAt<S, K1>>>>>, K6>>>

export function get<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<Index<Index<Unpack<Unpack<KeyAt<S, K1>>>>>>>>

export function get<K1 extends string, T2, T3, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<Index<Unpack<Unpack<KeyAt<S, K1>>>>>>>

export function get<K1 extends string, T2, T3, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A6>>

export function get<K1 extends string, T2, T3, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Index<Unpack<Unpack<KeyAt<S, K1>>>>, Unpack<Index<Unpack<Unpack<KeyAt<S, K1>>>>>, KeyAt<Unpack<Index<Unpack<Unpack<KeyAt<S, K1>>>>>, K6>>>>

export function get<K1 extends string, T2, T3, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Index<Unpack<Unpack<KeyAt<S, K1>>>>, Unpack<Index<Unpack<Unpack<KeyAt<S, K1>>>>>, Index<Unpack<Index<Unpack<Unpack<KeyAt<S, K1>>>>>>>>>

export function get<K1 extends string, T2, T3, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(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, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Index<Unpack<Unpack<KeyAt<S, K1>>>>, Unpack<Index<Unpack<Unpack<KeyAt<S, K1>>>>>, A6>>>

export function get<K1 extends string, T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, KeyAt<A5, K6>>>

export function get<K1 extends string, T2, T3, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Index<A5>>>

export function get<K1 extends string, T2, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A5>>

export function get<K1 extends string, T2, T3, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A6>>

export function get<K1 extends string, T2, T3, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, KeyAt<KeyAt<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, K5>, K6>>>>

export function get<K1 extends string, T2, T3, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Index<KeyAt<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, K5>>>>>

export function get<K1 extends string, T2, T3, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, KeyAt<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, K5>>>>

export function get<K1 extends string, T2, T3, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, A6>>>

export function get<K1 extends string, T2, T3, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, KeyAt<Index<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>>, K6>>>>

export function get<K1 extends string, T2, T3, T4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Index<Index<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>>>>>>

export function get<K1 extends string, T2, T3, T4, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Index<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>>>>>

export function get<K1 extends string, T2, T3, T4, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, A6>>>

export function get<K1 extends string, T2, T3, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Functor<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Unpack<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>>, KeyAt<Unpack<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>>, K6>>>>>

export function get<K1 extends string, T2, T3, T4, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Functor<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Unpack<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>>, Index<Unpack<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>>>>>>>

export function get<K1 extends string, T2, T3, T4, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<S, K1>

export function get<K1 extends string, T2, T3, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Functor<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Unpack<Unpack<Unpack<Unpack<KeyAt<S, K1>>>>>, A6>>>>

export function get<K1 extends string, T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, KeyAt<A5, K6>>>>

export function get<K1 extends string, T2, T3, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, Index<A5>>>>

export function get<K1 extends string, T2, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, A5>>>

export function get<K1 extends string, T2, T3, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, Functor<Unpack<Unpack<KeyAt<S, K1>>>, Unpack<Unpack<Unpack<KeyAt<S, K1>>>>, A6>>>

export function get<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <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>>>, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <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>>>, Index<KeyAt<A4, K5>>>>

export function get<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <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>>>, KeyAt<A4, K5>>>

export function get<K1 extends string, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <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>>>, A6>>

export function get<K1 extends string, T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <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>>>, KeyAt<Index<A4>, K6>>>

export function get<K1 extends string, T2, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <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>>>, Index<Index<A4>>>>

export function get<K1 extends string, T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <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>>>, Index<A4>>>

export function get<K1 extends string, T2, T3, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <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>>>, A6>>

export function get<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A4>, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A4>, T5, Index<T5>>>

export function get<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <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, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Functor<Unpack<KeyAt<S, K1>>, Unpack<Unpack<KeyAt<S, K1>>>, A4>, T5, A6>>

export function get<K1 extends string, T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <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>>>, KeyAt<A5, K6>>>

export function get<K1 extends string, T2, T3, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <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>>>, Index<A5>>>

export function get<K1 extends string, T2, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <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>>>, A5>>

export function get<K1 extends string, T2, T3, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <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>>>, A6>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<KeyAt<A3, K4>, K5>>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<A3, K4>, K5>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<KeyAt<A3, K4>>, K6>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<KeyAt<A3, K4>>>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<A3, K4>>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<A3, K4>, T5, Index<T5>>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <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 HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<KeyAt<A3, K4>, T5, A6>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<Index<A3>, K5>, K6>>

export function get<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<Index<A3>, K5>>>

export function get<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<A3>, K5>>

export function get<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<Index<A3>>, K6>>

export function get<K1 extends string, T2, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<Index<A3>>>>

export function get<K1 extends string, T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<A3>>>

export function get<K1 extends string, T2, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<A3>, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<A3>, T5, Index<T5>>>

export function get<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <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 Indexable<Collection<T5>>, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Index<A3>, T5, A6>>

export function get<K1 extends string, T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, S3, A3 extends Indexable, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, Index<KeyAt<T4, K5>>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, KeyAt<T4, K5>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, A6>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, KeyAt<Index<T4>, K6>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, Index<Index<T4>>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, Index<T4>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, A6>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Functor<A3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Functor<A3, T4, T4>, T5, Index<T5>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <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 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<Functor<A3, T4, T4>, T5, A6>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, KeyAt<A5, K6>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, Index<A5>>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, A5>>

export function get<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A3, T4, A6>>

export function get<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<KeyAt<A4, K5>>>

export function get<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A4, K5>>

export function get<K1 extends string, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<Index<A4>, K6>>

export function get<K1 extends string, T2, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<Index<A4>>>

export function get<K1 extends string, T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A4>>

export function get<K1 extends string, T2, S3, A3, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, Index<T5>>>

export function get<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A4>

export function get<K1 extends string, T2, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Functor<A4, T5, A6>>

export function get<K1 extends string, T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, KeyAt<A5, K6>>

export function get<K1 extends string, T2, S3, A3, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, Index<A5>>

export function get<K1 extends string, T2, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A5>

export function get<K1 extends string, T2, S3, A3, A4, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => Functor<KeyAt<S, K1>, Unpack<KeyAt<S, K1>>, A6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<KeyAt<KeyAt<A2, K3>, K4>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, Index<T5>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<KeyAt<A2, K3>, K4>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, A6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<Index<KeyAt<A2, K3>>, K5>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<Index<KeyAt<A2, K3>>>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<Index<KeyAt<A2, K3>>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<Index<KeyAt<A2, K3>>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<Index<KeyAt<A2, K3>>, T5, Index<T5>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<KeyAt<A2, K3>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<Index<KeyAt<A2, K3>>, T5, A6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, Index<KeyAt<T4, K5>>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, KeyAt<T4, K5>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, KeyAt<Index<T4>, K6>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, Index<Index<T4>>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, Index<T4>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, Index<T5>>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<A2, K3>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, A6>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, KeyAt<A5, K6>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, Index<A5>>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, A5>

export function get<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<A4, K5>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<A4>>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<A4>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A4

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<A4, T5, A6>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<KeyAt<Index<A2>, K4>, K5>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<KeyAt<Index<A2>, K4>>>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<KeyAt<Index<A2>, K4>>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<KeyAt<Index<A2>, K4>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<KeyAt<Index<A2>, K4>, T5, Index<T5>>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<Index<A2>, K4>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<KeyAt<Index<A2>, K4>, T5, A6>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<Index<Index<A2>>, K5>>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<Index<Index<A2>>, K5>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<Index<Index<A2>>>, K6>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<Index<Index<A2>>>>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<Index<Index<A2>>>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable>>, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<Index<Index<A2>>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<Index<Index<A2>>, T5, Index<T5>>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<Index<A2>>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<Index<Index<A2>>, T5, A6>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2 extends Indexable<Indexable>, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, Index<KeyAt<T4, K5>>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, KeyAt<T4, K5>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, A6>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, KeyAt<Index<T4>, K6>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, Index<Index<T4>>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, Index<T4>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, A6>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, Functor<T4, T5, Index<T5>>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<A2>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, Functor<T4, T5, A6>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, KeyAt<A5, K6>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, Index<A5>>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, A5>

export function get<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => Functor<Index<A2>, T4, A6>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<A4, K5>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<A4>>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<A4>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A4

export function get<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<A4, T5, A6>

export function get<K1 extends string, S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2 extends Indexable, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2 extends Indexable, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<KeyAt<KeyAt<T3, K4>, K5>, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<KeyAt<KeyAt<T3, K4>, K5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<KeyAt<T3, K4>, K5>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<Index<KeyAt<T3, K4>>, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<Index<KeyAt<T3, K4>>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<KeyAt<T3, K4>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, Index<T5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<T3, K4>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, A6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<A5>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A5>

export function get<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<KeyAt<Index<T3>, K5>, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<KeyAt<Index<T3>, K5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<Index<T3>, K5>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<Index<Index<T3>>, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<Index<Index<T3>>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<Index<T3>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<Index<T3>, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<Index<T3>, T5, Index<T5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<T3>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<Index<T3>, T5, A6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<A5>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A5>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, Index<KeyAt<T4, K5>>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, KeyAt<T4, K5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, KeyAt<Index<T4>, K6>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, Index<Index<T4>>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, Index<T4>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, Index<T5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A2

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, A6>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, KeyAt<A5, K6>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, Index<A5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, A5>>

export function get<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<KeyAt<A4, K5>, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<KeyAt<A4, K5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<A4, K5>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<Index<A4>, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<Index<A4>>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<A4>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<A4, T5, Index<T5>>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A4>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, Functor<A4, T5, A6>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, S2>) => Functor<A2, T3, Index<A5>>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A5>

export function get<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => Functor<A2, T3, A6>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<KeyAt<A3, K4>, K5>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<KeyAt<A3, K4>>>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<KeyAt<A3, K4>>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<A3, K4>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<Index<A3>, K5>>

export function get<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<Index<A3>, K5>

export function get<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<Index<A3>>, K6>

export function get<K1 extends string, S2, A2, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<Index<A3>>>

export function get<K1 extends string, S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<Index<A3>>

export function get<K1 extends string, S2, A2, A3 extends Indexable<Indexable>, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<Index<A3>, T5, Index<T5>>

export function get<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<A3>

export function get<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<Index<A3>, T5, A6>

export function get<K1 extends string, S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2, A3 extends Indexable, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2, A3 extends Indexable, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: HasKey<K1, S2>) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: HasKey<K1, S2>) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: HasKey<K1, S2>) => Functor<A3, T4, A6>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: HasKey<K1, S2>) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: HasKey<K1, S2>) => Functor<A3, T4, Index<Index<T4>>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A3, T4, Index<T4>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: HasKey<K1, S2>) => Functor<A3, T4, A6>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A3

export function get<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: HasKey<K1, S2>) => Functor<A3, T4, Index<A5>>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Functor<A3, T4, A5>

export function get<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => Functor<A3, T4, A6>

export function get<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: HasKey<K1, S2>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: HasKey<K1, S2>) => Index<KeyAt<A4, K5>>

export function get<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: HasKey<K1, S2>) => KeyAt<A4, K5>

export function get<K1 extends string, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: HasKey<K1, S2>) => KeyAt<Index<A4>, K6>

export function get<K1 extends string, S2, A2, A3, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: HasKey<K1, S2>) => Index<Index<A4>>

export function get<K1 extends string, S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: HasKey<K1, S2>) => Index<A4>

export function get<K1 extends string, S2, A2, A3, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: HasKey<K1, S2>) => A6

export function get<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: HasKey<K1, S2>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: HasKey<K1, S2>) => Functor<A4, T5, Index<T5>>

export function get<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A4

export function get<K1 extends string, S2, A2, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: HasKey<K1, S2>) => Functor<A4, T5, A6>

export function get<K1 extends string, S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: HasKey<K1, S2>) => KeyAt<A5, K6>

export function get<K1 extends string, S2, A2, A3, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: HasKey<K1, S2>) => Index<A5>

export function get<K1 extends string, S2, A2, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: HasKey<K1, S2>) => A5

export function get<K1 extends string, S2, A2, A3, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: HasKey<K1, S2>) => A6

export function get<K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>, K5>, K6>

export function get<K2 extends string, K3 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>, K5>>

export function get<K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>, K5>

export function get<K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (s: Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>) => A6

export function get<K2 extends string, K3 extends string, K4 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>>, K6>

export function get<K2 extends string, K3 extends string, K4 extends string>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Index<Index<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>>>

export function get<K2 extends string, K3 extends string, K4 extends string, T6>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Index<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>>

export function get<K2 extends string, K3 extends string, K4 extends string, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (s: Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>) => A6

export function get<K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>>, K6>>

export function get<K2 extends string, K3 extends string, K4 extends string, T5>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>>>>

export function get<K2 extends string, K3 extends string, K4 extends string, T5, T6>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>

export function get<K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<Index<S>, K2>, K3>, K4>>, A6>

export function get<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (s: Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => KeyAt<A5, K6>

export function get<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (s: Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => Index<A5>

export function get<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => A5

export function get<K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>) => A6

export function get<K2 extends string, K3 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>, K5>, K6>

export function get<K2 extends string, K3 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>, K5>>

export function get<K2 extends string, K3 extends string, K5 extends string, T6>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>, K5>

export function get<K2 extends string, K3 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (s: Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>) => A6

export function get<K2 extends string, K3 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>>, K6>

export function get<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3, i4: number, i5: number, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Index<Index<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>>>

export function get<K2 extends string, K3 extends string, T6>(i1: number, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Index<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>>

export function get<K2 extends string, K3 extends string, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (s: Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>) => A6

export function get<K2 extends string, K3 extends string, T5, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>>, KeyAt<Unpack<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>>, K6>>

export function get<K2 extends string, K3 extends string, T5>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>>, Index<Unpack<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>>>>

export function get<K2 extends string, K3 extends string, T5, T6>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<KeyAt<KeyAt<Index<S>, K2>, K3>>

export function get<K2 extends string, K3 extends string, T5, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<Index<S>, K2>, K3>>>, A6>

export function get<K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (s: Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>) => KeyAt<A5, K6>

export function get<K2 extends string, K3 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (s: Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>) => Index<A5>

export function get<K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>) => A5

export function get<K2 extends string, K3 extends string, S5, A5, A6>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>) => A6

export function get<K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, K5>, K6>>

export function get<K2 extends string, K3 extends string, T4, K5 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Index<KeyAt<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, K5>>>

export function get<K2 extends string, K3 extends string, T4, K5 extends string, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, KeyAt<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, K5>>

export function get<K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, A6>

export function get<K2 extends string, K3 extends string, T4, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, KeyAt<Index<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>>, K6>>

export function get<K2 extends string, K3 extends string, T4>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Index<Index<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>>>>

export function get<K2 extends string, K3 extends string, T4, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Index<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>>>

export function get<K2 extends string, K3 extends string, T4, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, A6>

export function get<K2 extends string, K3 extends string, T4, T5, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>>, K6>>>

export function get<K2 extends string, K3 extends string, T4, T5>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>>, Index<Unpack<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>>>>>

export function get<K2 extends string, K3 extends string, T4, T5, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<Index<S>, K2>, K3>

export function get<K2 extends string, K3 extends string, T4, T5, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>>, A6>>

export function get<K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, KeyAt<A5, K6>>

export function get<K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, Index<A5>>

export function get<K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, A5>

export function get<K2 extends string, K3 extends string, T4, S5, A5, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Index<S>, K2>, K3>>, A6>

export function get<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => Index<KeyAt<A4, K5>>

export function get<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => KeyAt<A4, K5>

export function get<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => A6

export function get<K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => KeyAt<Index<A4>, K6>

export function get<K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => Index<Index<A4>>

export function get<K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => Index<A4>

export function get<K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => A6

export function get<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => Functor<A4, T5, Index<T5>>

export function get<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => A4

export function get<K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => Functor<A4, T5, A6>

export function get<K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => KeyAt<A5, K6>

export function get<K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => Index<A5>

export function get<K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => A5

export function get<K2 extends string, K3 extends string, S4, A4, A5, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, HasKey<K3, S4>>>) => A6

export function get<K2 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>, K5>, K6>

export function get<K2 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>, K5>>

export function get<K2 extends string, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>, K5>

export function get<K2 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (s: Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>) => A6

export function get<K2 extends string, K4 extends string, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>>, K6>

export function get<K2 extends string, K4 extends string>(i1: number, k2: K2, i3: number, k4: K4, i5: number, i6: number): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Index<Index<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>>>

export function get<K2 extends string, K4 extends string, T6>(i1: number, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Index<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>>

export function get<K2 extends string, K4 extends string, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (s: Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>) => A6

export function get<K2 extends string, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>>, KeyAt<Unpack<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>>, K6>>

export function get<K2 extends string, K4 extends string, T5>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>>, Index<Unpack<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>>>>

export function get<K2 extends string, K4 extends string, T5, T6>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<Index<KeyAt<Index<S>, K2>>, K4>

export function get<K2 extends string, K4 extends string, T5, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<Index<S>, K2>>, K4>>, A6>

export function get<K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (s: Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>) => KeyAt<A5, K6>

export function get<K2 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (s: Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>) => Index<A5>

export function get<K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>) => A5

export function get<K2 extends string, K4 extends string, S5, A5, A6>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>) => A6

export function get<K2 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<Index<Index<KeyAt<Index<S>, K2>>>, K5>, K6>

export function get<K2 extends string, K5 extends string>(i1: number, k2: K2, i3: number, i4: number, k5: K5, i6: number): <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<Index<Index<KeyAt<Index<S>, K2>>>, K5>>

export function get<K2 extends string, K5 extends string, T6>(i1: number, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<Index<Index<KeyAt<Index<S>, K2>>>, K5>

export function get<K2 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (s: Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>) => A6

export function get<K2 extends string, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, i5: number, k6: K6): <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<Index<Index<KeyAt<Index<S>, K2>>>>, K6>

export function get<K2 extends string>(i1: number, k2: K2, i3: number, i4: number, i5: number, i6: number): <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Index<Index<Index<Index<KeyAt<Index<S>, K2>>>>>

export function get<K2 extends string, T6>(i1: number, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Index<Index<Index<KeyAt<Index<S>, K2>>>>

export function get<K2 extends string, S6, A6>(i1: number, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (s: Indexable<HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>) => A6

export function get<K2 extends string, T5, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<KeyAt<Index<S>, K2>>>, Unpack<Index<Index<KeyAt<Index<S>, K2>>>>, KeyAt<Unpack<Index<Index<KeyAt<Index<S>, K2>>>>, K6>>

export function get<K2 extends string, T5>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<KeyAt<Index<S>, K2>>>, Unpack<Index<Index<KeyAt<Index<S>, K2>>>>, Index<Unpack<Index<Index<KeyAt<Index<S>, K2>>>>>>

export function get<K2 extends string, T5, T6>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<Index<KeyAt<Index<S>, K2>>>

export function get<K2 extends string, T5, S6, A6>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<KeyAt<Index<S>, K2>>>, Unpack<Index<Index<KeyAt<Index<S>, K2>>>>, A6>

export function get<K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (s: Indexable<HasKey<K2, Indexable<Indexable<S5>>>>) => KeyAt<A5, K6>

export function get<K2 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (s: Indexable<HasKey<K2, Indexable<Indexable<S5>>>>) => Index<A5>

export function get<K2 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, Indexable<Indexable<S5>>>>) => A5

export function get<K2 extends string, S5, A5, A6>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, Indexable<Indexable<S5>>>>) => A6

export function get<K2 extends string, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, KeyAt<KeyAt<Unpack<Index<KeyAt<Index<S>, K2>>>, K5>, K6>>

export function get<K2 extends string, T4, K5 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, Index<KeyAt<Unpack<Index<KeyAt<Index<S>, K2>>>, K5>>>

export function get<K2 extends string, T4, K5 extends string, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, KeyAt<Unpack<Index<KeyAt<Index<S>, K2>>>, K5>>

export function get<K2 extends string, T4, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, A6>

export function get<K2 extends string, T4, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, KeyAt<Index<Unpack<Index<KeyAt<Index<S>, K2>>>>, K6>>

export function get<K2 extends string, T4>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, Index<Index<Unpack<Index<KeyAt<Index<S>, K2>>>>>>

export function get<K2 extends string, T4, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, Index<Unpack<Index<KeyAt<Index<S>, K2>>>>>

export function get<K2 extends string, T4, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, A6>

export function get<K2 extends string, T4, T5, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, Functor<Unpack<Index<KeyAt<Index<S>, K2>>>, Unpack<Unpack<Index<KeyAt<Index<S>, K2>>>>, KeyAt<Unpack<Unpack<Index<KeyAt<Index<S>, K2>>>>, K6>>>

export function get<K2 extends string, T4, T5>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, Functor<Unpack<Index<KeyAt<Index<S>, K2>>>, Unpack<Unpack<Index<KeyAt<Index<S>, K2>>>>, Index<Unpack<Unpack<Index<KeyAt<Index<S>, K2>>>>>>>

export function get<K2 extends string, T4, T5, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<KeyAt<Index<S>, K2>>

export function get<K2 extends string, T4, T5, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, Functor<Unpack<Index<KeyAt<Index<S>, K2>>>, Unpack<Unpack<Index<KeyAt<Index<S>, K2>>>>, A6>>

export function get<K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, KeyAt<A5, K6>>

export function get<K2 extends string, T4, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, Index<A5>>

export function get<K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, A5>

export function get<K2 extends string, T4, S5, A5, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<KeyAt<Index<S>, K2>>, Unpack<Index<KeyAt<Index<S>, K2>>>, A6>

export function get<K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (s: Indexable<HasKey<K2, Indexable<S4>>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (s: Indexable<HasKey<K2, Indexable<S4>>>) => Index<KeyAt<A4, K5>>

export function get<K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => KeyAt<A4, K5>

export function get<K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => A6

export function get<K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (s: Indexable<HasKey<K2, Indexable<S4>>>) => KeyAt<Index<A4>, K6>

export function get<K2 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (s: Indexable<HasKey<K2, Indexable<S4>>>) => Index<Index<A4>>

export function get<K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => Index<A4>

export function get<K2 extends string, S4, A4 extends Indexable, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => A6

export function get<K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<HasKey<K2, Indexable<S4>>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<HasKey<K2, Indexable<S4>>>) => Functor<A4, T5, Index<T5>>

export function get<K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => A4

export function get<K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => Functor<A4, T5, A6>

export function get<K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<HasKey<K2, Indexable<S4>>>) => KeyAt<A5, K6>

export function get<K2 extends string, S4, A4, A5 extends Indexable>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<HasKey<K2, Indexable<S4>>>) => Index<A5>

export function get<K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => A5

export function get<K2 extends string, S4, A4, A5, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, Indexable<S4>>>) => A6

export function get<K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<KeyAt<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>, K5>, K6>>

export function get<K2 extends string, T3, K4 extends string, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<KeyAt<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>, K5>>>

export function get<K2 extends string, T3, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>, K5>>

export function get<K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, T3, K4 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<Index<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>, K6>>

export function get<K2 extends string, T3, K4 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<Index<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>>>

export function get<K2 extends string, T3, K4 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>>

export function get<K2 extends string, T3, K4 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, T3, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>, K6>>>

export function get<K2 extends string, T3, K4 extends string, T5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>, Index<Unpack<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>>>>

export function get<K2 extends string, T3, K4 extends string, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(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, K4 extends string, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<Index<S>, K2>>, K4>>, A6>>

export function get<K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<A5, K6>>

export function get<K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<A5>>

export function get<K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A5>

export function get<K2 extends string, T3, K4 extends string, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, T3, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<KeyAt<Index<Unpack<KeyAt<Index<S>, K2>>>, K5>, K6>>

export function get<K2 extends string, T3, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<KeyAt<Index<Unpack<KeyAt<Index<S>, K2>>>, K5>>>

export function get<K2 extends string, T3, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<Index<Unpack<KeyAt<Index<S>, K2>>>, K5>>

export function get<K2 extends string, T3, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, T3, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<Index<Index<Unpack<KeyAt<Index<S>, K2>>>>, K6>>

export function get<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<Index<Index<Unpack<KeyAt<Index<S>, K2>>>>>>

export function get<K2 extends string, T3, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<Index<Unpack<KeyAt<Index<S>, K2>>>>>

export function get<K2 extends string, T3, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, T3, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Index<Unpack<KeyAt<Index<S>, K2>>>, Unpack<Index<Unpack<KeyAt<Index<S>, K2>>>>, KeyAt<Unpack<Index<Unpack<KeyAt<Index<S>, K2>>>>, K6>>>

export function get<K2 extends string, T3, T5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Index<Unpack<KeyAt<Index<S>, K2>>>, Unpack<Index<Unpack<KeyAt<Index<S>, K2>>>>, Index<Unpack<Index<Unpack<KeyAt<Index<S>, K2>>>>>>>

export function get<K2 extends string, T3, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(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, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Index<Unpack<KeyAt<Index<S>, K2>>>, Unpack<Index<Unpack<KeyAt<Index<S>, K2>>>>, A6>>

export function get<K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<A5, K6>>

export function get<K2 extends string, T3, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<A5>>

export function get<K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A5>

export function get<K2 extends string, T3, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, T3, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, KeyAt<KeyAt<Unpack<Unpack<KeyAt<Index<S>, K2>>>, K5>, K6>>>

export function get<K2 extends string, T3, T4, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, Index<KeyAt<Unpack<Unpack<KeyAt<Index<S>, K2>>>, K5>>>>

export function get<K2 extends string, T3, T4, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, KeyAt<Unpack<Unpack<KeyAt<Index<S>, K2>>>, K5>>>

export function get<K2 extends string, T3, T4, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, A6>>

export function get<K2 extends string, T3, T4, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, KeyAt<Index<Unpack<Unpack<KeyAt<Index<S>, K2>>>>, K6>>>

export function get<K2 extends string, T3, T4>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, Index<Index<Unpack<Unpack<KeyAt<Index<S>, K2>>>>>>>

export function get<K2 extends string, T3, T4, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, Index<Unpack<Unpack<KeyAt<Index<S>, K2>>>>>>

export function get<K2 extends string, T3, T4, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, A6>>

export function get<K2 extends string, T3, T4, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, Functor<Unpack<Unpack<KeyAt<Index<S>, K2>>>, Unpack<Unpack<Unpack<KeyAt<Index<S>, K2>>>>, KeyAt<Unpack<Unpack<Unpack<KeyAt<Index<S>, K2>>>>, K6>>>>

export function get<K2 extends string, T3, T4, T5>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, Functor<Unpack<Unpack<KeyAt<Index<S>, K2>>>, Unpack<Unpack<Unpack<KeyAt<Index<S>, K2>>>>, Index<Unpack<Unpack<Unpack<KeyAt<Index<S>, K2>>>>>>>>

export function get<K2 extends string, T3, T4, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<Index<S>, K2>

export function get<K2 extends string, T3, T4, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, Functor<Unpack<Unpack<KeyAt<Index<S>, K2>>>, Unpack<Unpack<Unpack<KeyAt<Index<S>, K2>>>>, A6>>>

export function get<K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, KeyAt<A5, K6>>>

export function get<K2 extends string, T3, T4, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, Index<A5>>>

export function get<K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, A5>>

export function get<K2 extends string, T3, T4, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<Unpack<KeyAt<Index<S>, K2>>, Unpack<Unpack<KeyAt<Index<S>, K2>>>, A6>>

export function get<K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<KeyAt<A4, K5>>>

export function get<K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<A4, K5>>

export function get<K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<Index<A4>, K6>>

export function get<K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<Index<A4>>>

export function get<K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<A4>>

export function get<K2 extends string, T3, S4, A4 extends Indexable, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<A4, T5, Index<T5>>>

export function get<K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <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, T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Functor<A4, T5, A6>>

export function get<K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, KeyAt<A5, K6>>

export function get<K2 extends string, T3, S4, A4, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, Index<A5>>

export function get<K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A5>

export function get<K2 extends string, T3, S4, A4, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<KeyAt<Index<S>, K2>, Unpack<KeyAt<Index<S>, K2>>, A6>

export function get<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => KeyAt<KeyAt<A3, K4>, K5>

export function get<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<Index<KeyAt<A3, K4>>>

export function get<K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => Index<KeyAt<A3, K4>>

export function get<K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: Indexable<HasKey<K2, S3>>) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: Indexable<HasKey<K2, S3>>) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => KeyAt<A3, K4>

export function get<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<HasKey<K2, S3>>) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<A5, K6>

export function get<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<A5>

export function get<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => A5

export function get<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<KeyAt<Index<A3>, K5>>

export function get<K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => KeyAt<Index<A3>, K5>

export function get<K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<Index<Index<A3>>, K6>

export function get<K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<Index<Index<A3>>>

export function get<K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => Index<Index<A3>>

export function get<K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: Indexable<HasKey<K2, S3>>) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: Indexable<HasKey<K2, S3>>) => Functor<Index<A3>, T5, Index<T5>>

export function get<K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => Index<A3>

export function get<K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<HasKey<K2, S3>>) => Functor<Index<A3>, T5, A6>

export function get<K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<A5, K6>

export function get<K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<A5>

export function get<K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => A5

export function get<K2 extends string, S3, A3 extends Indexable, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, A6>

export function get<K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, Index<Index<T4>>>

export function get<K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, Index<T4>>

export function get<K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, A6>

export function get<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => A3

export function get<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, Index<A5>>

export function get<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, A5>

export function get<K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, S3>>) => Functor<A3, T4, A6>

export function get<K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<KeyAt<A4, K5>>

export function get<K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => KeyAt<A4, K5>

export function get<K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<Index<A4>, K6>

export function get<K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<Index<A4>>

export function get<K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => Index<A4>

export function get<K2 extends string, S3, A3, A4 extends Indexable, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<HasKey<K2, S3>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<HasKey<K2, S3>>) => Functor<A4, T5, Index<T5>>

export function get<K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => A4

export function get<K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<HasKey<K2, S3>>) => Functor<A4, T5, A6>

export function get<K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<HasKey<K2, S3>>) => KeyAt<A5, K6>

export function get<K2 extends string, S3, A3, A4, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<HasKey<K2, S3>>) => Index<A5>

export function get<K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<HasKey<K2, S3>>) => A5

export function get<K2 extends string, S3, A3, A4, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<HasKey<K2, S3>>) => A6

export function get<K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>, K5>, K6>

export function get<K3 extends string, K4 extends string, K5 extends string>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>, K5>>

export function get<K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>, K5>

export function get<K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (s: Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>) => A6

export function get<K3 extends string, K4 extends string, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>>, K6>

export function get<K3 extends string, K4 extends string>(i1: number, i2: number, k3: K3, k4: K4, i5: number, i6: number): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Index<Index<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>>>

export function get<K3 extends string, K4 extends string, T6>(i1: number, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Index<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>>

export function get<K3 extends string, K4 extends string, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (s: Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>) => A6

export function get<K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>>, K6>>

export function get<K3 extends string, K4 extends string, T5>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>>>>

export function get<K3 extends string, K4 extends string, T5, T6>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<Index<Index<S>>, K3>, K4>

export function get<K3 extends string, K4 extends string, T5, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<Index<S>>, K3>, K4>>, A6>

export function get<K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (s: Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>) => KeyAt<A5, K6>

export function get<K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (s: Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>) => Index<A5>

export function get<K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>) => A5

export function get<K3 extends string, K4 extends string, S5, A5, A6>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>) => A6

export function get<K3 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<Index<KeyAt<Index<Index<S>>, K3>>, K5>, K6>

export function get<K3 extends string, K5 extends string>(i1: number, i2: number, k3: K3, i4: number, k5: K5, i6: number): <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<Index<KeyAt<Index<Index<S>>, K3>>, K5>>

export function get<K3 extends string, K5 extends string, T6>(i1: number, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<Index<KeyAt<Index<Index<S>>, K3>>, K5>

export function get<K3 extends string, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (s: Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>) => A6

export function get<K3 extends string, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, i5: number, k6: K6): <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<Index<KeyAt<Index<Index<S>>, K3>>>, K6>

export function get<K3 extends string>(i1: number, i2: number, k3: K3, i4: number, i5: number, i6: number): <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Index<Index<Index<KeyAt<Index<Index<S>>, K3>>>>

export function get<K3 extends string, T6>(i1: number, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Index<Index<KeyAt<Index<Index<S>>, K3>>>

export function get<K3 extends string, S6, A6>(i1: number, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (s: Indexable<Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>) => A6

export function get<K3 extends string, T5, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<KeyAt<Index<Index<S>>, K3>>, Unpack<Index<KeyAt<Index<Index<S>>, K3>>>, KeyAt<Unpack<Index<KeyAt<Index<Index<S>>, K3>>>, K6>>

export function get<K3 extends string, T5>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<KeyAt<Index<Index<S>>, K3>>, Unpack<Index<KeyAt<Index<Index<S>>, K3>>>, Index<Unpack<Index<KeyAt<Index<Index<S>>, K3>>>>>

export function get<K3 extends string, T5, T6>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<KeyAt<Index<Index<S>>, K3>>

export function get<K3 extends string, T5, S6, A6>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<KeyAt<Index<Index<S>>, K3>>, Unpack<Index<KeyAt<Index<Index<S>>, K3>>>, A6>

export function get<K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (s: Indexable<Indexable<HasKey<K3, Indexable<S5>>>>) => KeyAt<A5, K6>

export function get<K3 extends string, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (s: Indexable<Indexable<HasKey<K3, Indexable<S5>>>>) => Index<A5>

export function get<K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<HasKey<K3, Indexable<S5>>>>) => A5

export function get<K3 extends string, S5, A5, A6>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<HasKey<K3, Indexable<S5>>>>) => A6

export function get<K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<Index<Index<S>>, K3>>, K5>, K6>>

export function get<K3 extends string, T4, K5 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, Index<KeyAt<Unpack<KeyAt<Index<Index<S>>, K3>>, K5>>>

export function get<K3 extends string, T4, K5 extends string, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, KeyAt<Unpack<KeyAt<Index<Index<S>>, K3>>, K5>>

export function get<K3 extends string, T4, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, A6>

export function get<K3 extends string, T4, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, KeyAt<Index<Unpack<KeyAt<Index<Index<S>>, K3>>>, K6>>

export function get<K3 extends string, T4>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, Index<Index<Unpack<KeyAt<Index<Index<S>>, K3>>>>>

export function get<K3 extends string, T4, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, Index<Unpack<KeyAt<Index<Index<S>>, K3>>>>

export function get<K3 extends string, T4, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, A6>

export function get<K3 extends string, T4, T5, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, Functor<Unpack<KeyAt<Index<Index<S>>, K3>>, Unpack<Unpack<KeyAt<Index<Index<S>>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<Index<Index<S>>, K3>>>, K6>>>

export function get<K3 extends string, T4, T5>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, Functor<Unpack<KeyAt<Index<Index<S>>, K3>>, Unpack<Unpack<KeyAt<Index<Index<S>>, K3>>>, Index<Unpack<Unpack<KeyAt<Index<Index<S>>, K3>>>>>>

export function get<K3 extends string, T4, T5, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<Index<Index<S>>, K3>

export function get<K3 extends string, T4, T5, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, Functor<Unpack<KeyAt<Index<Index<S>>, K3>>, Unpack<Unpack<KeyAt<Index<Index<S>>, K3>>>, A6>>

export function get<K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, KeyAt<A5, K6>>

export function get<K3 extends string, T4, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, Index<A5>>

export function get<K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, A5>

export function get<K3 extends string, T4, S5, A5, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<KeyAt<Index<Index<S>>, K3>, Unpack<KeyAt<Index<Index<S>>, K3>>, A6>

export function get<K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (s: Indexable<Indexable<HasKey<K3, S4>>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (s: Indexable<Indexable<HasKey<K3, S4>>>) => Index<KeyAt<A4, K5>>

export function get<K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => KeyAt<A4, K5>

export function get<K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => A6

export function get<K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (s: Indexable<Indexable<HasKey<K3, S4>>>) => KeyAt<Index<A4>, K6>

export function get<K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (s: Indexable<Indexable<HasKey<K3, S4>>>) => Index<Index<A4>>

export function get<K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => Index<A4>

export function get<K3 extends string, S4, A4 extends Indexable, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => A6

export function get<K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<Indexable<HasKey<K3, S4>>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<Indexable<HasKey<K3, S4>>>) => Functor<A4, T5, Index<T5>>

export function get<K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => A4

export function get<K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => Functor<A4, T5, A6>

export function get<K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<Indexable<HasKey<K3, S4>>>) => KeyAt<A5, K6>

export function get<K3 extends string, S4, A4, A5 extends Indexable>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<Indexable<HasKey<K3, S4>>>) => Index<A5>

export function get<K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => A5

export function get<K3 extends string, S4, A4, A5, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<HasKey<K3, S4>>>) => A6

export function get<K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<KeyAt<Index<Index<Index<S>>>, K4>, K5>, K6>

export function get<K4 extends string, K5 extends string>(i1: number, i2: number, i3: number, k4: K4, k5: K5, i6: number): <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<KeyAt<Index<Index<Index<S>>>, K4>, K5>>

export function get<K4 extends string, K5 extends string, T6>(i1: number, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<KeyAt<Index<Index<Index<S>>>, K4>, K5>

export function get<K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (s: Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>) => A6

export function get<K4 extends string, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, i5: number, k6: K6): <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<KeyAt<Index<Index<Index<S>>>, K4>>, K6>

export function get<K4 extends string>(i1: number, i2: number, i3: number, k4: K4, i5: number, i6: number): <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Index<Index<KeyAt<Index<Index<Index<S>>>, K4>>>

export function get<K4 extends string, T6>(i1: number, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Index<KeyAt<Index<Index<Index<S>>>, K4>>

export function get<K4 extends string, S6, A6>(i1: number, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (s: Indexable<Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>) => A6

export function get<K4 extends string, T5, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<KeyAt<Index<Index<Index<S>>>, K4>, Unpack<KeyAt<Index<Index<Index<S>>>, K4>>, KeyAt<Unpack<KeyAt<Index<Index<Index<S>>>, K4>>, K6>>

export function get<K4 extends string, T5>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<KeyAt<Index<Index<Index<S>>>, K4>, Unpack<KeyAt<Index<Index<Index<S>>>, K4>>, Index<Unpack<KeyAt<Index<Index<Index<S>>>, K4>>>>

export function get<K4 extends string, T5, T6>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => KeyAt<Index<Index<Index<S>>>, K4>

export function get<K4 extends string, T5, S6, A6>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<KeyAt<Index<Index<Index<S>>>, K4>, Unpack<KeyAt<Index<Index<Index<S>>>, K4>>, A6>

export function get<K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (s: Indexable<Indexable<Indexable<HasKey<K4, S5>>>>) => KeyAt<A5, K6>

export function get<K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (s: Indexable<Indexable<Indexable<HasKey<K4, S5>>>>) => Index<A5>

export function get<K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<Indexable<HasKey<K4, S5>>>>) => A5

export function get<K4 extends string, S5, A5, A6>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<Indexable<HasKey<K4, S5>>>>) => A6

export function get<K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, i4: number, k5: K5, k6: K6): <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => KeyAt<KeyAt<Index<Index<Index<Index<S>>>>, K5>, K6>

export function get<K5 extends string>(i1: number, i2: number, i3: number, i4: number, k5: K5, i6: number): <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Index<KeyAt<Index<Index<Index<Index<S>>>>, K5>>

export function get<K5 extends string, T6>(i1: number, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => KeyAt<Index<Index<Index<Index<S>>>>, K5>

export function get<K5 extends string, S6, A6>(i1: number, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (s: Indexable<Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>) => A6

export function get<K6 extends string>(i1: number, i2: number, i3: number, i4: number, i5: number, k6: K6): <S extends Indexable<Indexable<Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => KeyAt<Index<Index<Index<Index<Index<S>>>>>, K6>

export function get(i1: number, i2: number, i3: number, i4: number, i5: number, i6: number): <S extends Indexable<Indexable<Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Index<Index<Index<Index<Index<Index<S>>>>>>

export function get<T6>(i1: number, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Index<Index<Index<Index<Index<S>>>>>

export function get<S6, A6>(i1: number, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (s: Indexable<Indexable<Indexable<Indexable<Indexable<S6>>>>>) => A6

export function get<T5, K6 extends string>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<Index<Index<S>>>>, Unpack<Index<Index<Index<Index<S>>>>>, KeyAt<Unpack<Index<Index<Index<Index<S>>>>>, K6>>

export function get<T5>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<Index<Index<S>>>>, Unpack<Index<Index<Index<Index<S>>>>>, Index<Unpack<Index<Index<Index<Index<S>>>>>>>

export function get<T5, T6>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<Index<Index<Index<S>>>>

export function get<T5, S6, A6>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<Index<Index<S>>>>, Unpack<Index<Index<Index<Index<S>>>>>, A6>

export function get<S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (s: Indexable<Indexable<Indexable<Indexable<S5>>>>) => KeyAt<A5, K6>

export function get<S5, A5 extends Indexable>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (s: Indexable<Indexable<Indexable<Indexable<S5>>>>) => Index<A5>

export function get<S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<Indexable<Indexable<S5>>>>) => A5

export function get<S5, A5, A6>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<Indexable<Indexable<S5>>>>) => A6

export function get<T4, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, KeyAt<KeyAt<Unpack<Index<Index<Index<S>>>>, K5>, K6>>

export function get<T4, K5 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, Index<KeyAt<Unpack<Index<Index<Index<S>>>>, K5>>>

export function get<T4, K5 extends string, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, KeyAt<Unpack<Index<Index<Index<S>>>>, K5>>

export function get<T4, K5 extends string, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, A6>

export function get<T4, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, KeyAt<Index<Unpack<Index<Index<Index<S>>>>>, K6>>

export function get<T4>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, Index<Index<Unpack<Index<Index<Index<S>>>>>>>

export function get<T4, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, Index<Unpack<Index<Index<Index<S>>>>>>

export function get<T4, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, A6>

export function get<T4, T5, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, Functor<Unpack<Index<Index<Index<S>>>>, Unpack<Unpack<Index<Index<Index<S>>>>>, KeyAt<Unpack<Unpack<Index<Index<Index<S>>>>>, K6>>>

export function get<T4, T5>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, Functor<Unpack<Index<Index<Index<S>>>>, Unpack<Unpack<Index<Index<Index<S>>>>>, Index<Unpack<Unpack<Index<Index<Index<S>>>>>>>>

export function get<T4, T5, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<Index<Index<S>>>

export function get<T4, T5, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, Functor<Unpack<Index<Index<Index<S>>>>, Unpack<Unpack<Index<Index<Index<S>>>>>, A6>>

export function get<T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, KeyAt<A5, K6>>

export function get<T4, S5, A5 extends Indexable>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, Index<A5>>

export function get<T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, A5>

export function get<T4, S5, A5, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<Index<S>>>, Unpack<Index<Index<Index<S>>>>, A6>

export function get<S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (s: Indexable<Indexable<Indexable<S4>>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (s: Indexable<Indexable<Indexable<S4>>>) => Index<KeyAt<A4, K5>>

export function get<S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<Indexable<Indexable<S4>>>) => KeyAt<A4, K5>

export function get<S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<Indexable<Indexable<S4>>>) => A6

export function get<S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (s: Indexable<Indexable<Indexable<S4>>>) => KeyAt<Index<A4>, K6>

export function get<S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (s: Indexable<Indexable<Indexable<S4>>>) => Index<Index<A4>>

export function get<S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<Indexable<Indexable<S4>>>) => Index<A4>

export function get<S4, A4 extends Indexable, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<Indexable<Indexable<S4>>>) => A6

export function get<S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<Indexable<Indexable<S4>>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<Indexable<Indexable<S4>>>) => Functor<A4, T5, Index<T5>>

export function get<S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<Indexable<Indexable<S4>>>) => A4

export function get<S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<Indexable<Indexable<S4>>>) => Functor<A4, T5, A6>

export function get<S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<Indexable<Indexable<S4>>>) => KeyAt<A5, K6>

export function get<S4, A4, A5 extends Indexable>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<Indexable<Indexable<S4>>>) => Index<A5>

export function get<S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<Indexable<S4>>>) => A5

export function get<S4, A4, A5, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<Indexable<S4>>>) => A6

export function get<T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<KeyAt<KeyAt<Unpack<Index<Index<S>>>, K4>, K5>, K6>>

export function get<T3, K4 extends string, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<KeyAt<KeyAt<Unpack<Index<Index<S>>>, K4>, K5>>>

export function get<T3, K4 extends string, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<KeyAt<Unpack<Index<Index<S>>>, K4>, K5>>

export function get<T3, K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<T3, K4 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<Index<KeyAt<Unpack<Index<Index<S>>>, K4>>, K6>>

export function get<T3, K4 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<Index<KeyAt<Unpack<Index<Index<S>>>, K4>>>>

export function get<T3, K4 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<KeyAt<Unpack<Index<Index<S>>>, K4>>>

export function get<T3, K4 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<T3, K4 extends string, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<KeyAt<Unpack<Index<Index<S>>>, K4>, Unpack<KeyAt<Unpack<Index<Index<S>>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<Index<Index<S>>>, K4>>, K6>>>

export function get<T3, K4 extends string, T5>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<KeyAt<Unpack<Index<Index<S>>>, K4>, Unpack<KeyAt<Unpack<Index<Index<S>>>, K4>>, Index<Unpack<KeyAt<Unpack<Index<Index<S>>>, K4>>>>>

export function get<T3, K4 extends string, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<Unpack<Index<Index<S>>>, K4>>

export function get<T3, K4 extends string, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<KeyAt<Unpack<Index<Index<S>>>, K4>, Unpack<KeyAt<Unpack<Index<Index<S>>>, K4>>, A6>>

export function get<T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<A5, K6>>

export function get<T3, K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<A5>>

export function get<T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A5>

export function get<T3, K4 extends string, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<T3, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<KeyAt<Index<Unpack<Index<Index<S>>>>, K5>, K6>>

export function get<T3, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<KeyAt<Index<Unpack<Index<Index<S>>>>, K5>>>

export function get<T3, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<Index<Unpack<Index<Index<S>>>>, K5>>

export function get<T3, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<T3, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<Index<Index<Unpack<Index<Index<S>>>>>, K6>>

export function get<T3>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<Index<Index<Unpack<Index<Index<S>>>>>>>

export function get<T3, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<Index<Unpack<Index<Index<S>>>>>>

export function get<T3, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<T3, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Index<Unpack<Index<Index<S>>>>, Unpack<Index<Unpack<Index<Index<S>>>>>, KeyAt<Unpack<Index<Unpack<Index<Index<S>>>>>, K6>>>

export function get<T3, T5>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Index<Unpack<Index<Index<S>>>>, Unpack<Index<Unpack<Index<Index<S>>>>>, Index<Unpack<Index<Unpack<Index<Index<S>>>>>>>>

export function get<T3, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<Unpack<Index<Index<S>>>>>

export function get<T3, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Index<Unpack<Index<Index<S>>>>, Unpack<Index<Unpack<Index<Index<S>>>>>, A6>>

export function get<T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<A5, K6>>

export function get<T3, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<A5>>

export function get<T3, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A5>

export function get<T3, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<T3, T4, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, KeyAt<KeyAt<Unpack<Unpack<Index<Index<S>>>>, K5>, K6>>>

export function get<T3, T4, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, Index<KeyAt<Unpack<Unpack<Index<Index<S>>>>, K5>>>>

export function get<T3, T4, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, KeyAt<Unpack<Unpack<Index<Index<S>>>>, K5>>>

export function get<T3, T4, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, A6>>

export function get<T3, T4, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, KeyAt<Index<Unpack<Unpack<Index<Index<S>>>>>, K6>>>

export function get<T3, T4>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, Index<Index<Unpack<Unpack<Index<Index<S>>>>>>>>

export function get<T3, T4, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, Index<Unpack<Unpack<Index<Index<S>>>>>>>

export function get<T3, T4, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, A6>>

export function get<T3, T4, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, Functor<Unpack<Unpack<Index<Index<S>>>>, Unpack<Unpack<Unpack<Index<Index<S>>>>>, KeyAt<Unpack<Unpack<Unpack<Index<Index<S>>>>>, K6>>>>

export function get<T3, T4, T5>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, Functor<Unpack<Unpack<Index<Index<S>>>>, Unpack<Unpack<Unpack<Index<Index<S>>>>>, Index<Unpack<Unpack<Unpack<Index<Index<S>>>>>>>>>

export function get<T3, T4, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<Index<S>>

export function get<T3, T4, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, Functor<Unpack<Unpack<Index<Index<S>>>>, Unpack<Unpack<Unpack<Index<Index<S>>>>>, A6>>>

export function get<T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, KeyAt<A5, K6>>>

export function get<T3, T4, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, Index<A5>>>

export function get<T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, A5>>

export function get<T3, T4, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<Unpack<Index<Index<S>>>, Unpack<Unpack<Index<Index<S>>>>, A6>>

export function get<T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<KeyAt<A4, K5>>>

export function get<T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<A4, K5>>

export function get<T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<Index<A4>, K6>>

export function get<T3, S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<Index<A4>>>

export function get<T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<A4>>

export function get<T3, S4, A4 extends Indexable, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<A4, T5, Index<T5>>>

export function get<T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A4>

export function get<T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Functor<A4, T5, A6>>

export function get<T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, KeyAt<A5, K6>>

export function get<T3, S4, A4, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, Index<A5>>

export function get<T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A5>

export function get<T3, S4, A4, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => Functor<Index<Index<S>>, Unpack<Index<Index<S>>>, A6>

export function get<S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (s: Indexable<Indexable<S3>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => KeyAt<KeyAt<A3, K4>, K5>

export function get<S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (s: Indexable<Indexable<S3>>) => Index<Index<KeyAt<A3, K4>>>

export function get<S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => Index<KeyAt<A3, K4>>

export function get<S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: Indexable<Indexable<S3>>) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: Indexable<Indexable<S3>>) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => KeyAt<A3, K4>

export function get<S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<Indexable<S3>>) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<A5, K6>

export function get<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: Indexable<Indexable<S3>>) => Index<A5>

export function get<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => A5

export function get<S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (s: Indexable<Indexable<S3>>) => Index<KeyAt<Index<A3>, K5>>

export function get<S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => KeyAt<Index<A3>, K5>

export function get<S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<Index<Index<A3>>, K6>

export function get<S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (s: Indexable<Indexable<S3>>) => Index<Index<Index<A3>>>

export function get<S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => Index<Index<A3>>

export function get<S3, A3 extends Indexable<Indexable>, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: Indexable<Indexable<S3>>) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: Indexable<Indexable<S3>>) => Functor<Index<A3>, T5, Index<T5>>

export function get<S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => Index<A3>

export function get<S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<Indexable<S3>>) => Functor<Index<A3>, T5, A6>

export function get<S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<A5, K6>

export function get<S3, A3 extends Indexable, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: Indexable<Indexable<S3>>) => Index<A5>

export function get<S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => A5

export function get<S3, A3 extends Indexable, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, A6>

export function get<S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, Index<Index<T4>>>

export function get<S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, Index<T4>>

export function get<S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, A6>

export function get<S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => A3

export function get<S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, Index<A5>>

export function get<S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, A5>

export function get<S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<S3>>) => Functor<A3, T4, A6>

export function get<S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: Indexable<Indexable<S3>>) => Index<KeyAt<A4, K5>>

export function get<S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => KeyAt<A4, K5>

export function get<S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<Index<A4>, K6>

export function get<S3, A3, A4 extends Indexable<Indexable>>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: Indexable<Indexable<S3>>) => Index<Index<A4>>

export function get<S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => Index<A4>

export function get<S3, A3, A4 extends Indexable, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<Indexable<S3>>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<Indexable<S3>>) => Functor<A4, T5, Index<T5>>

export function get<S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => A4

export function get<S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<Indexable<S3>>) => Functor<A4, T5, A6>

export function get<S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<Indexable<S3>>) => KeyAt<A5, K6>

export function get<S3, A3, A4, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<Indexable<S3>>) => Index<A5>

export function get<S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<Indexable<S3>>) => A5

export function get<S3, A3, A4, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<Indexable<S3>>) => A6

export function get<T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>, K5>, K6>>

export function get<T2, K3 extends string, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>, K5>>>

export function get<T2, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>, K5>>

export function get<T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K3 extends string, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>, K6>>

export function get<T2, K3 extends string, K4 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>>>

export function get<T2, K3 extends string, K4 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>>

export function get<T2, K3 extends string, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>, K6>>>

export function get<T2, K3 extends string, K4 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>>>>

export function get<T2, K3 extends string, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>

export function get<T2, K3 extends string, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<Index<S>>, K3>, K4>>, A6>>

export function get<T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, K3 extends string, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K3 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<Index<KeyAt<Unpack<Index<S>>, K3>>, K5>, K6>>

export function get<T2, K3 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<Index<KeyAt<Unpack<Index<S>>, K3>>, K5>>>

export function get<T2, K3 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<KeyAt<Unpack<Index<S>>, K3>>, K5>>

export function get<T2, K3 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K3 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<Index<KeyAt<Unpack<Index<S>>, K3>>>, K6>>

export function get<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<Index<KeyAt<Unpack<Index<S>>, K3>>>>>

export function get<T2, K3 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<KeyAt<Unpack<Index<S>>, K3>>>>

export function get<T2, K3 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K3 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<KeyAt<Unpack<Index<S>>, K3>>, Unpack<Index<KeyAt<Unpack<Index<S>>, K3>>>, KeyAt<Unpack<Index<KeyAt<Unpack<Index<S>>, K3>>>, K6>>>

export function get<T2, K3 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<KeyAt<Unpack<Index<S>>, K3>>, Unpack<Index<KeyAt<Unpack<Index<S>>, K3>>>, Index<Unpack<Index<KeyAt<Unpack<Index<S>>, K3>>>>>>

export function get<T2, K3 extends string, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<Unpack<Index<S>>, K3>>>

export function get<T2, K3 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<KeyAt<Unpack<Index<S>>, K3>>, Unpack<Index<KeyAt<Unpack<Index<S>>, K3>>>, A6>>

export function get<T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, K3 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, K3 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<Unpack<Index<S>>, K3>>, K5>, K6>>>

export function get<T2, K3 extends string, T4, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, Index<KeyAt<Unpack<KeyAt<Unpack<Index<S>>, K3>>, K5>>>>

export function get<T2, K3 extends string, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, KeyAt<Unpack<KeyAt<Unpack<Index<S>>, K3>>, K5>>>

export function get<T2, K3 extends string, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, A6>>

export function get<T2, K3 extends string, T4, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, KeyAt<Index<Unpack<KeyAt<Unpack<Index<S>>, K3>>>, K6>>>

export function get<T2, K3 extends string, T4>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, Index<Index<Unpack<KeyAt<Unpack<Index<S>>, K3>>>>>>

export function get<T2, K3 extends string, T4, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, Index<Unpack<KeyAt<Unpack<Index<S>>, K3>>>>>

export function get<T2, K3 extends string, T4, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, A6>>

export function get<T2, K3 extends string, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, Functor<Unpack<KeyAt<Unpack<Index<S>>, K3>>, Unpack<Unpack<KeyAt<Unpack<Index<S>>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<Unpack<Index<S>>, K3>>>, K6>>>>

export function get<T2, K3 extends string, T4, T5>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, Functor<Unpack<KeyAt<Unpack<Index<S>>, K3>>, Unpack<Unpack<KeyAt<Unpack<Index<S>>, K3>>>, Index<Unpack<Unpack<KeyAt<Unpack<Index<S>>, K3>>>>>>>

export function get<T2, K3 extends string, T4, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Unpack<Index<S>>, K3>>

export function get<T2, K3 extends string, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, Functor<Unpack<KeyAt<Unpack<Index<S>>, K3>>, Unpack<Unpack<KeyAt<Unpack<Index<S>>, K3>>>, A6>>>

export function get<T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, KeyAt<A5, K6>>>

export function get<T2, K3 extends string, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, Index<A5>>>

export function get<T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, A5>>

export function get<T2, K3 extends string, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Unpack<Index<S>>, K3>, Unpack<KeyAt<Unpack<Index<S>>, K3>>, A6>>

export function get<T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<A4, K5>>>

export function get<T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A4, K5>>

export function get<T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<A4>, K6>>

export function get<T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<A4>>>

export function get<T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A4>>

export function get<T2, K3 extends string, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, Index<T5>>>

export function get<T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A4>

export function get<T2, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, A6>>

export function get<T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, K3 extends string, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, K3 extends string, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<KeyAt<Index<Unpack<Index<S>>>, K4>, K5>, K6>>

export function get<T2, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<KeyAt<Index<Unpack<Index<S>>>, K4>, K5>>>

export function get<T2, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<Index<Unpack<Index<S>>>, K4>, K5>>

export function get<T2, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<KeyAt<Index<Unpack<Index<S>>>, K4>>, K6>>

export function get<T2, K4 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<KeyAt<Index<Unpack<Index<S>>>, K4>>>>

export function get<T2, K4 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<Index<Unpack<Index<S>>>, K4>>>

export function get<T2, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Index<Unpack<Index<S>>>, K4>, Unpack<KeyAt<Index<Unpack<Index<S>>>, K4>>, KeyAt<Unpack<KeyAt<Index<Unpack<Index<S>>>, K4>>, K6>>>

export function get<T2, K4 extends string, T5>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Index<Unpack<Index<S>>>, K4>, Unpack<KeyAt<Index<Unpack<Index<S>>>, K4>>, Index<Unpack<KeyAt<Index<Unpack<Index<S>>>, K4>>>>>

export function get<T2, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<Unpack<Index<S>>>, K4>>

export function get<T2, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<Index<Unpack<Index<S>>>, K4>, Unpack<KeyAt<Index<Unpack<Index<S>>>, K4>>, A6>>

export function get<T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<Index<Index<Unpack<Index<S>>>>, K5>, K6>>

export function get<T2, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<Index<Index<Unpack<Index<S>>>>, K5>>>

export function get<T2, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<Index<Unpack<Index<S>>>>, K5>>

export function get<T2, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<Index<Index<Unpack<Index<S>>>>>, K6>>

export function get<T2>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<Index<Index<Unpack<Index<S>>>>>>>

export function get<T2, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<Index<Unpack<Index<S>>>>>>

export function get<T2, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Index<Unpack<Index<S>>>>, Unpack<Index<Index<Unpack<Index<S>>>>>, KeyAt<Unpack<Index<Index<Unpack<Index<S>>>>>, K6>>>

export function get<T2, T5>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Index<Unpack<Index<S>>>>, Unpack<Index<Index<Unpack<Index<S>>>>>, Index<Unpack<Index<Index<Unpack<Index<S>>>>>>>>

export function get<T2, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<Unpack<Index<S>>>>>

export function get<T2, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Index<Unpack<Index<S>>>>, Unpack<Index<Index<Unpack<Index<S>>>>>, A6>>

export function get<T2, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, KeyAt<KeyAt<Unpack<Index<Unpack<Index<S>>>>, K5>, K6>>>

export function get<T2, T4, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, Index<KeyAt<Unpack<Index<Unpack<Index<S>>>>, K5>>>>

export function get<T2, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, KeyAt<Unpack<Index<Unpack<Index<S>>>>, K5>>>

export function get<T2, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, A6>>

export function get<T2, T4, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, KeyAt<Index<Unpack<Index<Unpack<Index<S>>>>>, K6>>>

export function get<T2, T4>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, Index<Index<Unpack<Index<Unpack<Index<S>>>>>>>>

export function get<T2, T4, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, Index<Unpack<Index<Unpack<Index<S>>>>>>>

export function get<T2, T4, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, A6>>

export function get<T2, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, Functor<Unpack<Index<Unpack<Index<S>>>>, Unpack<Unpack<Index<Unpack<Index<S>>>>>, KeyAt<Unpack<Unpack<Index<Unpack<Index<S>>>>>, K6>>>>

export function get<T2, T4, T5>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, Functor<Unpack<Index<Unpack<Index<S>>>>, Unpack<Unpack<Index<Unpack<Index<S>>>>>, Index<Unpack<Unpack<Index<Unpack<Index<S>>>>>>>>>

export function get<T2, T4, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Unpack<Index<S>>>>

export function get<T2, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, Functor<Unpack<Index<Unpack<Index<S>>>>, Unpack<Unpack<Index<Unpack<Index<S>>>>>, A6>>>

export function get<T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, KeyAt<A5, K6>>>

export function get<T2, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, Index<A5>>>

export function get<T2, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, A5>>

export function get<T2, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<Unpack<Index<S>>>, Unpack<Index<Unpack<Index<S>>>>, A6>>

export function get<T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<A4, K5>>>

export function get<T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A4, K5>>

export function get<T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<A4>, K6>>

export function get<T2, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<A4>>>

export function get<T2, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A4>>

export function get<T2, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T2, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, Index<T5>>>

export function get<T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A4>

export function get<T2, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, A6>>

export function get<T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<KeyAt<KeyAt<Unpack<Unpack<Index<S>>>, K4>, K5>, K6>>>

export function get<T2, T3, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<KeyAt<KeyAt<Unpack<Unpack<Index<S>>>, K4>, K5>>>>

export function get<T2, T3, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<KeyAt<Unpack<Unpack<Index<S>>>, K4>, K5>>>

export function get<T2, T3, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, T3, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<Index<KeyAt<Unpack<Unpack<Index<S>>>, K4>>, K6>>>

export function get<T2, T3, K4 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<Index<KeyAt<Unpack<Unpack<Index<S>>>, K4>>>>>

export function get<T2, T3, K4 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<KeyAt<Unpack<Unpack<Index<S>>>, K4>>>>

export function get<T2, T3, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, T3, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<KeyAt<Unpack<Unpack<Index<S>>>, K4>, Unpack<KeyAt<Unpack<Unpack<Index<S>>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<Unpack<Index<S>>>, K4>>, K6>>>>

export function get<T2, T3, K4 extends string, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<KeyAt<Unpack<Unpack<Index<S>>>, K4>, Unpack<KeyAt<Unpack<Unpack<Index<S>>>, K4>>, Index<Unpack<KeyAt<Unpack<Unpack<Index<S>>>, K4>>>>>>

export function get<T2, T3, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(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, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<KeyAt<Unpack<Unpack<Index<S>>>, K4>, Unpack<KeyAt<Unpack<Unpack<Index<S>>>, K4>>, A6>>>

export function get<T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<A5, K6>>>

export function get<T2, T3, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<A5>>>

export function get<T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A5>>

export function get<T2, T3, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, T3, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<KeyAt<Index<Unpack<Unpack<Index<S>>>>, K5>, K6>>>

export function get<T2, T3, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<KeyAt<Index<Unpack<Unpack<Index<S>>>>, K5>>>>

export function get<T2, T3, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<Index<Unpack<Unpack<Index<S>>>>, K5>>>

export function get<T2, T3, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, T3, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<Index<Index<Unpack<Unpack<Index<S>>>>>, K6>>>

export function get<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<Index<Index<Unpack<Unpack<Index<S>>>>>>>>

export function get<T2, T3, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<Index<Unpack<Unpack<Index<S>>>>>>>

export function get<T2, T3, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, T3, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Index<Unpack<Unpack<Index<S>>>>, Unpack<Index<Unpack<Unpack<Index<S>>>>>, KeyAt<Unpack<Index<Unpack<Unpack<Index<S>>>>>, K6>>>>

export function get<T2, T3, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Index<Unpack<Unpack<Index<S>>>>, Unpack<Index<Unpack<Unpack<Index<S>>>>>, Index<Unpack<Index<Unpack<Unpack<Index<S>>>>>>>>>

export function get<T2, T3, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(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, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Index<Unpack<Unpack<Index<S>>>>, Unpack<Index<Unpack<Unpack<Index<S>>>>>, A6>>>

export function get<T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<A5, K6>>>

export function get<T2, T3, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<A5>>>

export function get<T2, T3, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A5>>

export function get<T2, T3, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, T3, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, KeyAt<KeyAt<Unpack<Unpack<Unpack<Index<S>>>>, K5>, K6>>>>

export function get<T2, T3, T4, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, Index<KeyAt<Unpack<Unpack<Unpack<Index<S>>>>, K5>>>>>

export function get<T2, T3, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, KeyAt<Unpack<Unpack<Unpack<Index<S>>>>, K5>>>>

export function get<T2, T3, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, A6>>>

export function get<T2, T3, T4, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, KeyAt<Index<Unpack<Unpack<Unpack<Index<S>>>>>, K6>>>>

export function get<T2, T3, T4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, Index<Index<Unpack<Unpack<Unpack<Index<S>>>>>>>>>

export function get<T2, T3, T4, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, Index<Unpack<Unpack<Unpack<Index<S>>>>>>>>

export function get<T2, T3, T4, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, A6>>>

export function get<T2, T3, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, Functor<Unpack<Unpack<Unpack<Index<S>>>>, Unpack<Unpack<Unpack<Unpack<Index<S>>>>>, KeyAt<Unpack<Unpack<Unpack<Unpack<Index<S>>>>>, K6>>>>>

export function get<T2, T3, T4, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, Functor<Unpack<Unpack<Unpack<Index<S>>>>, Unpack<Unpack<Unpack<Unpack<Index<S>>>>>, Index<Unpack<Unpack<Unpack<Unpack<Index<S>>>>>>>>>>

export function get<T2, T3, T4, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Index<S>

export function get<T2, T3, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, Functor<Unpack<Unpack<Unpack<Index<S>>>>, Unpack<Unpack<Unpack<Unpack<Index<S>>>>>, A6>>>>

export function get<T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, KeyAt<A5, K6>>>>

export function get<T2, T3, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, Index<A5>>>>

export function get<T2, T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, A5>>>

export function get<T2, T3, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Functor<Unpack<Unpack<Index<S>>>, Unpack<Unpack<Unpack<Index<S>>>>, A6>>>

export function get<T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<KeyAt<A4, K5>>>>

export function get<T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<A4, K5>>>

export function get<T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<Index<A4>, K6>>>

export function get<T2, T3, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<Index<A4>>>>

export function get<T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<A4>>>

export function get<T2, T3, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A4>, T5, KeyAt<T5, K6>>>

export function get<T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A4>, T5, Index<T5>>>

export function get<T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <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, T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A4>, T5, A6>>

export function get<T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, KeyAt<A5, K6>>>

export function get<T2, T3, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, Index<A5>>>

export function get<T2, T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A5>>

export function get<T2, T3, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Unpack<Index<S>>, Unpack<Unpack<Index<S>>>, A6>>

export function get<T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>>

export function get<T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<KeyAt<A3, K4>, K5>>>

export function get<T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<A3, K4>, K5>>

export function get<T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<KeyAt<A3, K4>>, K6>>

export function get<T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<KeyAt<A3, K4>>>>

export function get<T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<A3, K4>>>

export function get<T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>>

export function get<T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<A3, K4>, T5, Index<T5>>>

export function get<T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A3, K4>>

export function get<T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<KeyAt<A3, K4>, T5, A6>>

export function get<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<Index<A3>, K5>, K6>>

export function get<T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<Index<A3>, K5>>>

export function get<T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<A3>, K5>>

export function get<T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<Index<A3>>, K6>>

export function get<T2, S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<Index<A3>>>>

export function get<T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<A3>>>

export function get<T2, S3, A3 extends Indexable<Indexable>, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<A3>, T5, KeyAt<T5, K6>>>

export function get<T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<A3>, T5, Index<T5>>>

export function get<T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A3>>

export function get<T2, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Index<A3>, T5, A6>>

export function get<T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, S3, A3 extends Indexable, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, S3, A3 extends Indexable, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, Index<KeyAt<T4, K5>>>>

export function get<T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, KeyAt<T4, K5>>>

export function get<T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, A6>>

export function get<T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, KeyAt<Index<T4>, K6>>>

export function get<T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, Index<Index<T4>>>>

export function get<T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, Index<T4>>>

export function get<T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, A6>>

export function get<T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Functor<A3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Functor<A3, T4, T4>, T5, Index<T5>>>

export function get<T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A3>

export function get<T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<Functor<A3, T4, T4>, T5, A6>>

export function get<T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, KeyAt<A5, K6>>>

export function get<T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, Index<A5>>>

export function get<T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, A5>>

export function get<T2, S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A3, T4, A6>>

export function get<T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<KeyAt<A4, K5>>>

export function get<T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A4, K5>>

export function get<T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<Index<A4>, K6>>

export function get<T2, S3, A3, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<Index<A4>>>

export function get<T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A4>>

export function get<T2, S3, A3, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, Index<T5>>>

export function get<T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A4>

export function get<T2, S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Functor<A4, T5, A6>>

export function get<T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, KeyAt<A5, K6>>

export function get<T2, S3, A3, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, Index<A5>>

export function get<T2, S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A5>

export function get<T2, S3, A3, A4, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Indexable<Collection<T2 & S3>>>(s: S) => Functor<Index<S>, Unpack<Index<S>>, A6>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<KeyAt<KeyAt<A2, K3>, K4>>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, KeyAt<T5, K6>>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, Index<T5>>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<KeyAt<A2, K3>, K4>

export function get<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, A6>

export function get<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>

export function get<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>

export function get<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<Index<KeyAt<A2, K3>>, K5>

export function get<S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>

export function get<S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<Index<KeyAt<A2, K3>>>>

export function get<S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<Index<KeyAt<A2, K3>>>

export function get<S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<Index<KeyAt<A2, K3>>, T5, KeyAt<T5, K6>>

export function get<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<Index<KeyAt<A2, K3>>, T5, Index<T5>>

export function get<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => Index<KeyAt<A2, K3>>

export function get<S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<Index<KeyAt<A2, K3>>, T5, A6>

export function get<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, Index<KeyAt<T4, K5>>>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, KeyAt<T4, K5>>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, KeyAt<Index<T4>, K6>>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, Index<Index<T4>>>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, Index<T4>>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, Index<T5>>>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<A2, K3>

export function get<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, A6>>

export function get<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, KeyAt<A5, K6>>

export function get<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, Index<A5>>

export function get<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, A5>

export function get<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<A4, K5>>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<A4, K5>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<A4>, K6>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<A4>>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<A4>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<A4, T5, Index<T5>>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => A4

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<A4, T5, A6>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>

export function get<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>

export function get<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<KeyAt<Index<A2>, K4>, K5>

export function get<S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>

export function get<S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<KeyAt<Index<A2>, K4>>>

export function get<S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<KeyAt<Index<A2>, K4>>

export function get<S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<KeyAt<Index<A2>, K4>, T5, KeyAt<T5, K6>>

export function get<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<KeyAt<Index<A2>, K4>, T5, Index<T5>>

export function get<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<Index<A2>, K4>

export function get<S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<KeyAt<Index<A2>, K4>, T5, A6>

export function get<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>

export function get<S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<Index<Index<A2>>, K5>>

export function get<S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<Index<Index<A2>>, K5>

export function get<S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<Index<Index<A2>>>, K6>

export function get<S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<Index<Index<A2>>>>

export function get<S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<Index<Index<A2>>>

export function get<S2, A2 extends Indexable<Indexable<Indexable>>, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<Index<Index<A2>>, T5, KeyAt<T5, K6>>

export function get<S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<Index<Index<A2>>, T5, Index<T5>>

export function get<S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => Index<Index<A2>>

export function get<S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<Index<Index<A2>>, T5, A6>

export function get<S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2 extends Indexable<Indexable>, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (s: Indexable<S2>) => Functor<Index<A2>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (s: Indexable<S2>) => Functor<Index<A2>, T4, Index<KeyAt<T4, K5>>>

export function get<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<Index<A2>, T4, KeyAt<T4, K5>>

export function get<S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: Indexable<S2>) => Functor<Index<A2>, T4, A6>

export function get<S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (s: Indexable<S2>) => Functor<Index<A2>, T4, KeyAt<Index<T4>, K6>>

export function get<S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (s: Indexable<S2>) => Functor<Index<A2>, T4, Index<Index<T4>>>

export function get<S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<Index<A2>, T4, Index<T4>>

export function get<S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: Indexable<S2>) => Functor<Index<A2>, T4, A6>

export function get<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<Index<A2>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<Index<A2>, T4, Functor<T4, T5, Index<T5>>>

export function get<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => Index<A2>

export function get<S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<Index<A2>, T4, Functor<T4, T5, A6>>

export function get<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: Indexable<S2>) => Functor<Index<A2>, T4, KeyAt<A5, K6>>

export function get<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: Indexable<S2>) => Functor<Index<A2>, T4, Index<A5>>

export function get<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<Index<A2>, T4, A5>

export function get<S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => Functor<Index<A2>, T4, A6>

export function get<S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<A4, K5>>

export function get<S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<A4, K5>

export function get<S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<A4>, K6>

export function get<S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<A4>>

export function get<S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<A4>

export function get<S2, A2 extends Indexable, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<A4, T5, Index<T5>>

export function get<S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => A4

export function get<S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<A4, T5, A6>

export function get<S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2 extends Indexable, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2 extends Indexable, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<KeyAt<KeyAt<T3, K4>, K5>, K6>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<KeyAt<KeyAt<T3, K4>, K5>>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<KeyAt<T3, K4>, K5>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<Index<KeyAt<T3, K4>>, K6>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<Index<KeyAt<T3, K4>>>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, Index<KeyAt<T3, K4>>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, KeyAt<T5, K6>>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, Index<T5>>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<T3, K4>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, A6>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<A5>>

export function get<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, A5>

export function get<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<KeyAt<Index<T3>, K5>, K6>>

export function get<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<KeyAt<Index<T3>, K5>>>

export function get<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<Index<T3>, K5>>

export function get<S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<Index<Index<T3>>, K6>>

export function get<S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<Index<Index<T3>>>>

export function get<S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, Index<Index<T3>>>

export function get<S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, Functor<Index<T3>, T5, KeyAt<T5, K6>>>

export function get<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Functor<Index<T3>, T5, Index<T5>>>

export function get<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, Index<T3>>

export function get<S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<Index<T3>, T5, A6>>

export function get<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<A5>>

export function get<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, A5>

export function get<S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, Index<KeyAt<T4, K5>>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, KeyAt<T4, K5>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, KeyAt<Index<T4>, K6>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, Index<Index<T4>>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, Index<T4>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, Index<T5>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => A2

export function get<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, A6>>

export function get<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, KeyAt<A5, K6>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, Index<A5>>>

export function get<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, A5>>

export function get<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<KeyAt<A4, K5>, K6>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<KeyAt<A4, K5>>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<A4, K5>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<Index<A4>, K6>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<Index<A4>>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, Index<A4>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Functor<A4, T5, Index<T5>>>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, A4>

export function get<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<A2, T3, Functor<A4, T5, A6>>

export function get<S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<S2>) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<S2>) => Functor<A2, T3, Index<A5>>

export function get<S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A2, T3, A5>

export function get<S2, A2 extends Collection<T3>, T3, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => Functor<A2, T3, A6>

export function get<S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<KeyAt<A3, K4>, K5>

export function get<S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<KeyAt<A3, K4>>>

export function get<S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<KeyAt<A3, K4>>

export function get<S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<A3, K4>

export function get<S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<Index<A3>, K5>>

export function get<S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<Index<A3>, K5>

export function get<S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<Index<A3>>, K6>

export function get<S2, A2, A3 extends Indexable<Indexable<Indexable>>>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<Index<A3>>>

export function get<S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<Index<A3>>

export function get<S2, A2, A3 extends Indexable<Indexable>, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<Index<A3>, T5, Index<T5>>

export function get<S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => Index<A3>

export function get<S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<Index<A3>, T5, A6>

export function get<S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2, A3 extends Indexable, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2, A3 extends Indexable, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: Indexable<S2>) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: Indexable<S2>) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: Indexable<S2>) => Functor<A3, T4, A6>

export function get<S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: Indexable<S2>) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: Indexable<S2>) => Functor<A3, T4, Index<Index<T4>>>

export function get<S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A3, T4, Index<T4>>

export function get<S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: Indexable<S2>) => Functor<A3, T4, A6>

export function get<S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => A3

export function get<S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: Indexable<S2>) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: Indexable<S2>) => Functor<A3, T4, Index<A5>>

export function get<S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => Functor<A3, T4, A5>

export function get<S2, A2, A3 extends Collection<T4>, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => Functor<A3, T4, A6>

export function get<S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: Indexable<S2>) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: Indexable<S2>) => Index<KeyAt<A4, K5>>

export function get<S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: Indexable<S2>) => KeyAt<A4, K5>

export function get<S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: Indexable<S2>) => KeyAt<Index<A4>, K6>

export function get<S2, A2, A3, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: Indexable<S2>) => Index<Index<A4>>

export function get<S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: Indexable<S2>) => Index<A4>

export function get<S2, A2, A3, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: Indexable<S2>) => A6

export function get<S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: Indexable<S2>) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: Indexable<S2>) => Functor<A4, T5, Index<T5>>

export function get<S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: Indexable<S2>) => A4

export function get<S2, A2, A3, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: Indexable<S2>) => Functor<A4, T5, A6>

export function get<S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: Indexable<S2>) => KeyAt<A5, K6>

export function get<S2, A2, A3, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: Indexable<S2>) => Index<A5>

export function get<S2, A2, A3, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: Indexable<S2>) => A5

export function get<S2, A2, A3, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: Indexable<S2>) => A6

export function get<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>, K5>, K6>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>, K5>>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>, K5>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>, K6>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>, K6>>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>>>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>, Unpack<KeyAt<KeyAt<KeyAt<Unpack<S>, K2>, K3>, K4>>, A6>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, K5>, K6>>

export function get<T1, K2 extends string, K3 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, K5>>>

export function get<T1, K2 extends string, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, K5>>

export function get<T1, K2 extends string, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K3 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, K6>>

export function get<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>>>

export function get<T1, K2 extends string, K3 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>>

export function get<T1, K2 extends string, K3 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, KeyAt<Unpack<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, K6>>>

export function get<T1, K2 extends string, K3 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, Index<Unpack<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>>>>

export function get<T1, K2 extends string, K3 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>

export function get<T1, K2 extends string, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Unpack<Index<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, A6>>

export function get<T1, K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, K5>, K6>>>

export function get<T1, K2 extends string, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Index<KeyAt<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, K5>>>>

export function get<T1, K2 extends string, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, KeyAt<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, K5>>>

export function get<T1, K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, A6>>

export function get<T1, K2 extends string, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, KeyAt<Index<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, K6>>>

export function get<T1, K2 extends string, K3 extends string, T4>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Index<Index<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>>>>

export function get<T1, K2 extends string, K3 extends string, T4, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Index<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>>>

export function get<T1, K2 extends string, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, A6>>

export function get<T1, K2 extends string, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, K6>>>>

export function get<T1, K2 extends string, K3 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, Index<Unpack<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>>>>>

export function get<T1, K2 extends string, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Unpack<S>, K2>, K3>>

export function get<T1, K2 extends string, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Functor<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Unpack<Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>>, A6>>>

export function get<T1, K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, KeyAt<A5, K6>>>

export function get<T1, K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, Index<A5>>>

export function get<T1, K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, A5>>

export function get<T1, K2 extends string, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Unpack<S>, K2>, K3>, Unpack<KeyAt<KeyAt<Unpack<S>, K2>, K3>>, A6>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>, K5>, K6>>

export function get<T1, K2 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>, K5>>>

export function get<T1, K2 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>, K5>>

export function get<T1, K2 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>, K6>>

export function get<T1, K2 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>>>

export function get<T1, K2 extends string, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>>

export function get<T1, K2 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>, KeyAt<Unpack<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>, K6>>>

export function get<T1, K2 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>, Index<Unpack<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>>>>

export function get<T1, K2 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>

export function get<T1, K2 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>, Unpack<KeyAt<Index<KeyAt<Unpack<S>, K2>>, K4>>, A6>>

export function get<T1, K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<Index<KeyAt<Unpack<S>, K2>>>, K5>, K6>>

export function get<T1, K2 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<Index<KeyAt<Unpack<S>, K2>>>, K5>>>

export function get<T1, K2 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<KeyAt<Unpack<S>, K2>>>, K5>>

export function get<T1, K2 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<Index<KeyAt<Unpack<S>, K2>>>>, K6>>

export function get<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<Index<KeyAt<Unpack<S>, K2>>>>>>

export function get<T1, K2 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<KeyAt<Unpack<S>, K2>>>>>

export function get<T1, K2 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<KeyAt<Unpack<S>, K2>>>, Unpack<Index<Index<KeyAt<Unpack<S>, K2>>>>, KeyAt<Unpack<Index<Index<KeyAt<Unpack<S>, K2>>>>, K6>>>

export function get<T1, K2 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<KeyAt<Unpack<S>, K2>>>, Unpack<Index<Index<KeyAt<Unpack<S>, K2>>>>, Index<Unpack<Index<Index<KeyAt<Unpack<S>, K2>>>>>>>

export function get<T1, K2 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<Unpack<S>, K2>>>>

export function get<T1, K2 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<KeyAt<Unpack<S>, K2>>>, Unpack<Index<Index<KeyAt<Unpack<S>, K2>>>>, A6>>

export function get<T1, K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, KeyAt<KeyAt<Unpack<Index<KeyAt<Unpack<S>, K2>>>, K5>, K6>>>

export function get<T1, K2 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, Index<KeyAt<Unpack<Index<KeyAt<Unpack<S>, K2>>>, K5>>>>

export function get<T1, K2 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, KeyAt<Unpack<Index<KeyAt<Unpack<S>, K2>>>, K5>>>

export function get<T1, K2 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, A6>>

export function get<T1, K2 extends string, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, KeyAt<Index<Unpack<Index<KeyAt<Unpack<S>, K2>>>>, K6>>>

export function get<T1, K2 extends string, T4>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, Index<Index<Unpack<Index<KeyAt<Unpack<S>, K2>>>>>>>

export function get<T1, K2 extends string, T4, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, Index<Unpack<Index<KeyAt<Unpack<S>, K2>>>>>>

export function get<T1, K2 extends string, T4, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, A6>>

export function get<T1, K2 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, Functor<Unpack<Index<KeyAt<Unpack<S>, K2>>>, Unpack<Unpack<Index<KeyAt<Unpack<S>, K2>>>>, KeyAt<Unpack<Unpack<Index<KeyAt<Unpack<S>, K2>>>>, K6>>>>

export function get<T1, K2 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, Functor<Unpack<Index<KeyAt<Unpack<S>, K2>>>, Unpack<Unpack<Index<KeyAt<Unpack<S>, K2>>>>, Index<Unpack<Unpack<Index<KeyAt<Unpack<S>, K2>>>>>>>>

export function get<T1, K2 extends string, T4, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Unpack<S>, K2>>>

export function get<T1, K2 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, Functor<Unpack<Index<KeyAt<Unpack<S>, K2>>>, Unpack<Unpack<Index<KeyAt<Unpack<S>, K2>>>>, A6>>>

export function get<T1, K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, KeyAt<A5, K6>>>

export function get<T1, K2 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, Index<A5>>>

export function get<T1, K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, A5>>

export function get<T1, K2 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Unpack<S>, K2>>, Unpack<Index<KeyAt<Unpack<S>, K2>>>, A6>>

export function get<T1, K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, K2 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, K2 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<KeyAt<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>, K5>, K6>>>

export function get<T1, K2 extends string, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<KeyAt<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>, K5>>>>

export function get<T1, K2 extends string, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>, K5>>>

export function get<T1, K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<Index<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>, K6>>>

export function get<T1, K2 extends string, T3, K4 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<Index<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>>>>

export function get<T1, K2 extends string, T3, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>>>

export function get<T1, K2 extends string, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>, K6>>>>

export function get<T1, K2 extends string, T3, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>, Index<Unpack<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>>>>>

export function get<T1, K2 extends string, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(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, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>, Unpack<KeyAt<Unpack<KeyAt<Unpack<S>, K2>>, K4>>, A6>>>

export function get<T1, K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<A5, K6>>>

export function get<T1, K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<A5>>>

export function get<T1, K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A5>>

export function get<T1, K2 extends string, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<KeyAt<Index<Unpack<KeyAt<Unpack<S>, K2>>>, K5>, K6>>>

export function get<T1, K2 extends string, T3, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<KeyAt<Index<Unpack<KeyAt<Unpack<S>, K2>>>, K5>>>>

export function get<T1, K2 extends string, T3, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<Index<Unpack<KeyAt<Unpack<S>, K2>>>, K5>>>

export function get<T1, K2 extends string, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, T3, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<Index<Index<Unpack<KeyAt<Unpack<S>, K2>>>>, K6>>>

export function get<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<Index<Index<Unpack<KeyAt<Unpack<S>, K2>>>>>>>

export function get<T1, K2 extends string, T3, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<Index<Unpack<KeyAt<Unpack<S>, K2>>>>>>

export function get<T1, K2 extends string, T3, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, T3, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Index<Unpack<KeyAt<Unpack<S>, K2>>>, Unpack<Index<Unpack<KeyAt<Unpack<S>, K2>>>>, KeyAt<Unpack<Index<Unpack<KeyAt<Unpack<S>, K2>>>>, K6>>>>

export function get<T1, K2 extends string, T3, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Index<Unpack<KeyAt<Unpack<S>, K2>>>, Unpack<Index<Unpack<KeyAt<Unpack<S>, K2>>>>, Index<Unpack<Index<Unpack<KeyAt<Unpack<S>, K2>>>>>>>>

export function get<T1, K2 extends string, T3, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(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, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Index<Unpack<KeyAt<Unpack<S>, K2>>>, Unpack<Index<Unpack<KeyAt<Unpack<S>, K2>>>>, A6>>>

export function get<T1, K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<A5, K6>>>

export function get<T1, K2 extends string, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<A5>>>

export function get<T1, K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A5>>

export function get<T1, K2 extends string, T3, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, KeyAt<KeyAt<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, K5>, K6>>>>

export function get<T1, K2 extends string, T3, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Index<KeyAt<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, K5>>>>>

export function get<T1, K2 extends string, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, KeyAt<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, K5>>>>

export function get<T1, K2 extends string, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, A6>>>

export function get<T1, K2 extends string, T3, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, KeyAt<Index<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>>, K6>>>>

export function get<T1, K2 extends string, T3, T4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Index<Index<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>>>>>>

export function get<T1, K2 extends string, T3, T4, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Index<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>>>>>

export function get<T1, K2 extends string, T3, T4, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, A6>>>

export function get<T1, K2 extends string, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Functor<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Unpack<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>>, KeyAt<Unpack<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>>, K6>>>>>

export function get<T1, K2 extends string, T3, T4, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Functor<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Unpack<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>>, Index<Unpack<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>>>>>>>

export function get<T1, K2 extends string, T3, T4, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Unpack<S>, K2>>

export function get<T1, K2 extends string, T3, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Functor<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Unpack<Unpack<Unpack<KeyAt<Unpack<S>, K2>>>>, A6>>>>

export function get<T1, K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, KeyAt<A5, K6>>>>

export function get<T1, K2 extends string, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, Index<A5>>>>

export function get<T1, K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, A5>>>

export function get<T1, K2 extends string, T3, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Functor<Unpack<KeyAt<Unpack<S>, K2>>, Unpack<Unpack<KeyAt<Unpack<S>, K2>>>, A6>>>

export function get<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<KeyAt<A4, K5>>>>

export function get<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<A4, K5>>>

export function get<T1, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<Index<A4>, K6>>>

export function get<T1, K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<Index<A4>>>>

export function get<T1, K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<A4>>>

export function get<T1, K2 extends string, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A4>, T5, KeyAt<T5, K6>>>

export function get<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A4>, T5, Index<T5>>>

export function get<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A4>>

export function get<T1, K2 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A4>, T5, A6>>

export function get<T1, K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, KeyAt<A5, K6>>>

export function get<T1, K2 extends string, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, Index<A5>>>

export function get<T1, K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A5>>

export function get<T1, K2 extends string, T3, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Unpack<S>, K2>, Unpack<KeyAt<Unpack<S>, K2>>, A6>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<A3, K4>, K5>>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A3, K4>, K5>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<A3, K4>>, K6>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<A3, K4>>>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A3, K4>>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, Index<T5>>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A3, K4>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, A6>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<A3>, K5>, K6>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<A3>, K5>>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A3>, K5>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<A3>>, K6>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<A3>>>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<Index<A3>>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, KeyAt<T5, K6>>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, Index<T5>>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<A3>>

export function get<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, A6>>

export function get<T1, K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<KeyAt<T4, K5>>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<T4, K5>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<Index<T4>, K6>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<Index<T4>>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<T4>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, Index<T5>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A3>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, A6>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<A5, K6>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<A5>>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A5>>

export function get<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, K2 extends string, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K2 extends string, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K2 extends string, S3, A3, A4, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>, K5>, K6>>

export function get<T1, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>, K5>>>

export function get<T1, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>, K5>>

export function get<T1, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>, K6>>

export function get<T1, K3 extends string, K4 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>>>

export function get<T1, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>>

export function get<T1, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>, K6>>>

export function get<T1, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>>>>

export function get<T1, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>

export function get<T1, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Index<Unpack<S>>, K3>, K4>>, A6>>

export function get<T1, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<KeyAt<Index<Unpack<S>>, K3>>, K5>, K6>>

export function get<T1, K3 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<KeyAt<Index<Unpack<S>>, K3>>, K5>>>

export function get<T1, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<Index<Unpack<S>>, K3>>, K5>>

export function get<T1, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<KeyAt<Index<Unpack<S>>, K3>>>, K6>>

export function get<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<KeyAt<Index<Unpack<S>>, K3>>>>>

export function get<T1, K3 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<Index<Unpack<S>>, K3>>>>

export function get<T1, K3 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Index<Unpack<S>>, K3>>, Unpack<Index<KeyAt<Index<Unpack<S>>, K3>>>, KeyAt<Unpack<Index<KeyAt<Index<Unpack<S>>, K3>>>, K6>>>

export function get<T1, K3 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Index<Unpack<S>>, K3>>, Unpack<Index<KeyAt<Index<Unpack<S>>, K3>>>, Index<Unpack<Index<KeyAt<Index<Unpack<S>>, K3>>>>>>

export function get<T1, K3 extends string, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<Unpack<S>>, K3>>>

export function get<T1, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<Index<Unpack<S>>, K3>>, Unpack<Index<KeyAt<Index<Unpack<S>>, K3>>>, A6>>

export function get<T1, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<Index<Unpack<S>>, K3>>, K5>, K6>>>

export function get<T1, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, Index<KeyAt<Unpack<KeyAt<Index<Unpack<S>>, K3>>, K5>>>>

export function get<T1, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, KeyAt<Unpack<KeyAt<Index<Unpack<S>>, K3>>, K5>>>

export function get<T1, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, A6>>

export function get<T1, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, KeyAt<Index<Unpack<KeyAt<Index<Unpack<S>>, K3>>>, K6>>>

export function get<T1, K3 extends string, T4>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, Index<Index<Unpack<KeyAt<Index<Unpack<S>>, K3>>>>>>

export function get<T1, K3 extends string, T4, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, Index<Unpack<KeyAt<Index<Unpack<S>>, K3>>>>>

export function get<T1, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, A6>>

export function get<T1, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, Functor<Unpack<KeyAt<Index<Unpack<S>>, K3>>, Unpack<Unpack<KeyAt<Index<Unpack<S>>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<Index<Unpack<S>>, K3>>>, K6>>>>

export function get<T1, K3 extends string, T4, T5>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, Functor<Unpack<KeyAt<Index<Unpack<S>>, K3>>, Unpack<Unpack<KeyAt<Index<Unpack<S>>, K3>>>, Index<Unpack<Unpack<KeyAt<Index<Unpack<S>>, K3>>>>>>>

export function get<T1, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Unpack<S>>, K3>>

export function get<T1, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, Functor<Unpack<KeyAt<Index<Unpack<S>>, K3>>, Unpack<Unpack<KeyAt<Index<Unpack<S>>, K3>>>, A6>>>

export function get<T1, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, KeyAt<A5, K6>>>

export function get<T1, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, Index<A5>>>

export function get<T1, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, A5>>

export function get<T1, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Unpack<S>>, K3>, Unpack<KeyAt<Index<Unpack<S>>, K3>>, A6>>

export function get<T1, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<Index<Index<Unpack<S>>>, K4>, K5>, K6>>

export function get<T1, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<Index<Index<Unpack<S>>>, K4>, K5>>>

export function get<T1, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<Index<Unpack<S>>>, K4>, K5>>

export function get<T1, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<Index<Index<Unpack<S>>>, K4>>, K6>>

export function get<T1, K4 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, i6: number): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<Index<Index<Unpack<S>>>, K4>>>>

export function get<T1, K4 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<Index<Unpack<S>>>, K4>>>

export function get<T1, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Index<Unpack<S>>>, K4>, Unpack<KeyAt<Index<Index<Unpack<S>>>, K4>>, KeyAt<Unpack<KeyAt<Index<Index<Unpack<S>>>, K4>>, K6>>>

export function get<T1, K4 extends string, T5>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Index<Unpack<S>>>, K4>, Unpack<KeyAt<Index<Index<Unpack<S>>>, K4>>, Index<Unpack<KeyAt<Index<Index<Unpack<S>>>, K4>>>>>

export function get<T1, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<Unpack<S>>>, K4>>

export function get<T1, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<Index<Unpack<S>>>, K4>, Unpack<KeyAt<Index<Index<Unpack<S>>>, K4>>, A6>>

export function get<T1, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<Index<Index<Unpack<S>>>>, K5>, K6>>

export function get<T1, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, i6: number): <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<Index<Index<Unpack<S>>>>, K5>>>

export function get<T1, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<Index<Unpack<S>>>>, K5>>

export function get<T1, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, k6: K6): <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<Index<Index<Unpack<S>>>>>, K6>>

export function get<T1>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, i6: number): <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<Index<Index<Unpack<S>>>>>>>

export function get<T1, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<Index<Unpack<S>>>>>>

export function get<T1, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Index<Unpack<S>>>>, Unpack<Index<Index<Index<Unpack<S>>>>>, KeyAt<Unpack<Index<Index<Index<Unpack<S>>>>>, K6>>>

export function get<T1, T5>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Index<Unpack<S>>>>, Unpack<Index<Index<Index<Unpack<S>>>>>, Index<Unpack<Index<Index<Index<Unpack<S>>>>>>>>

export function get<T1, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<Unpack<S>>>>>

export function get<T1, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Index<Unpack<S>>>>, Unpack<Index<Index<Index<Unpack<S>>>>>, A6>>

export function get<T1, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, KeyAt<KeyAt<Unpack<Index<Index<Unpack<S>>>>, K5>, K6>>>

export function get<T1, T4, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, Index<KeyAt<Unpack<Index<Index<Unpack<S>>>>, K5>>>>

export function get<T1, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, KeyAt<Unpack<Index<Index<Unpack<S>>>>, K5>>>

export function get<T1, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, A6>>

export function get<T1, T4, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, KeyAt<Index<Unpack<Index<Index<Unpack<S>>>>>, K6>>>

export function get<T1, T4>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, Index<Index<Unpack<Index<Index<Unpack<S>>>>>>>>

export function get<T1, T4, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, Index<Unpack<Index<Index<Unpack<S>>>>>>>

export function get<T1, T4, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, A6>>

export function get<T1, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, Functor<Unpack<Index<Index<Unpack<S>>>>, Unpack<Unpack<Index<Index<Unpack<S>>>>>, KeyAt<Unpack<Unpack<Index<Index<Unpack<S>>>>>, K6>>>>

export function get<T1, T4, T5>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, Functor<Unpack<Index<Index<Unpack<S>>>>, Unpack<Unpack<Index<Index<Unpack<S>>>>>, Index<Unpack<Unpack<Index<Index<Unpack<S>>>>>>>>>

export function get<T1, T4, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Unpack<S>>>>

export function get<T1, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, Functor<Unpack<Index<Index<Unpack<S>>>>, Unpack<Unpack<Index<Index<Unpack<S>>>>>, A6>>>

export function get<T1, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, KeyAt<A5, K6>>>

export function get<T1, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, Index<A5>>>

export function get<T1, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, A5>>

export function get<T1, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<Unpack<S>>>, Unpack<Index<Index<Unpack<S>>>>, A6>>

export function get<T1, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<KeyAt<KeyAt<Unpack<Index<Unpack<S>>>, K4>, K5>, K6>>>

export function get<T1, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<KeyAt<KeyAt<Unpack<Index<Unpack<S>>>, K4>, K5>>>>

export function get<T1, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<KeyAt<Unpack<Index<Unpack<S>>>, K4>, K5>>>

export function get<T1, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<Index<KeyAt<Unpack<Index<Unpack<S>>>, K4>>, K6>>>

export function get<T1, T3, K4 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<Index<KeyAt<Unpack<Index<Unpack<S>>>, K4>>>>>

export function get<T1, T3, K4 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<KeyAt<Unpack<Index<Unpack<S>>>, K4>>>>

export function get<T1, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<KeyAt<Unpack<Index<Unpack<S>>>, K4>, Unpack<KeyAt<Unpack<Index<Unpack<S>>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<Index<Unpack<S>>>, K4>>, K6>>>>

export function get<T1, T3, K4 extends string, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<KeyAt<Unpack<Index<Unpack<S>>>, K4>, Unpack<KeyAt<Unpack<Index<Unpack<S>>>, K4>>, Index<Unpack<KeyAt<Unpack<Index<Unpack<S>>>, K4>>>>>>

export function get<T1, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<Unpack<Index<Unpack<S>>>, K4>>>

export function get<T1, T3, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<KeyAt<Unpack<Index<Unpack<S>>>, K4>, Unpack<KeyAt<Unpack<Index<Unpack<S>>>, K4>>, A6>>>

export function get<T1, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<A5, K6>>>

export function get<T1, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<A5>>>

export function get<T1, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A5>>

export function get<T1, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<KeyAt<Index<Unpack<Index<Unpack<S>>>>, K5>, K6>>>

export function get<T1, T3, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<KeyAt<Index<Unpack<Index<Unpack<S>>>>, K5>>>>

export function get<T1, T3, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<Index<Unpack<Index<Unpack<S>>>>, K5>>>

export function get<T1, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, T3, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<Index<Index<Unpack<Index<Unpack<S>>>>>, K6>>>

export function get<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<Index<Index<Unpack<Index<Unpack<S>>>>>>>>

export function get<T1, T3, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<Index<Unpack<Index<Unpack<S>>>>>>>

export function get<T1, T3, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, T3, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Index<Unpack<Index<Unpack<S>>>>, Unpack<Index<Unpack<Index<Unpack<S>>>>>, KeyAt<Unpack<Index<Unpack<Index<Unpack<S>>>>>, K6>>>>

export function get<T1, T3, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Index<Unpack<Index<Unpack<S>>>>, Unpack<Index<Unpack<Index<Unpack<S>>>>>, Index<Unpack<Index<Unpack<Index<Unpack<S>>>>>>>>>

export function get<T1, T3, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<Unpack<Index<Unpack<S>>>>>>

export function get<T1, T3, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Index<Unpack<Index<Unpack<S>>>>, Unpack<Index<Unpack<Index<Unpack<S>>>>>, A6>>>

export function get<T1, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<A5, K6>>>

export function get<T1, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<A5>>>

export function get<T1, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A5>>

export function get<T1, T3, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, KeyAt<KeyAt<Unpack<Unpack<Index<Unpack<S>>>>, K5>, K6>>>>

export function get<T1, T3, T4, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, Index<KeyAt<Unpack<Unpack<Index<Unpack<S>>>>, K5>>>>>

export function get<T1, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, KeyAt<Unpack<Unpack<Index<Unpack<S>>>>, K5>>>>

export function get<T1, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, A6>>>

export function get<T1, T3, T4, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, KeyAt<Index<Unpack<Unpack<Index<Unpack<S>>>>>, K6>>>>

export function get<T1, T3, T4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, Index<Index<Unpack<Unpack<Index<Unpack<S>>>>>>>>>

export function get<T1, T3, T4, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, Index<Unpack<Unpack<Index<Unpack<S>>>>>>>>

export function get<T1, T3, T4, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, A6>>>

export function get<T1, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, Functor<Unpack<Unpack<Index<Unpack<S>>>>, Unpack<Unpack<Unpack<Index<Unpack<S>>>>>, KeyAt<Unpack<Unpack<Unpack<Index<Unpack<S>>>>>, K6>>>>>

export function get<T1, T3, T4, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, Functor<Unpack<Unpack<Index<Unpack<S>>>>, Unpack<Unpack<Unpack<Index<Unpack<S>>>>>, Index<Unpack<Unpack<Unpack<Index<Unpack<S>>>>>>>>>>

export function get<T1, T3, T4, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Index<Unpack<S>>>

export function get<T1, T3, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, Functor<Unpack<Unpack<Index<Unpack<S>>>>, Unpack<Unpack<Unpack<Index<Unpack<S>>>>>, A6>>>>

export function get<T1, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, KeyAt<A5, K6>>>>

export function get<T1, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, Index<A5>>>>

export function get<T1, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, A5>>>

export function get<T1, T3, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Functor<Unpack<Index<Unpack<S>>>, Unpack<Unpack<Index<Unpack<S>>>>, A6>>>

export function get<T1, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<T1, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<KeyAt<A4, K5>>>>

export function get<T1, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<A4, K5>>>

export function get<T1, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<Index<A4>, K6>>>

export function get<T1, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<Index<A4>>>>

export function get<T1, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<A4>>>

export function get<T1, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A4>, T5, KeyAt<T5, K6>>>

export function get<T1, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A4>, T5, Index<T5>>>

export function get<T1, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A4>>

export function get<T1, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A4>, T5, A6>>

export function get<T1, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, KeyAt<A5, K6>>>

export function get<T1, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, Index<A5>>>

export function get<T1, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A5>>

export function get<T1, T3, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Unpack<S>>, Unpack<Index<Unpack<S>>>, A6>>

export function get<T1, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>>

export function get<T1, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<A3, K4>, K5>>>

export function get<T1, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A3, K4>, K5>>

export function get<T1, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<A3, K4>>, K6>>

export function get<T1, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<A3, K4>>>>

export function get<T1, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A3, K4>>>

export function get<T1, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>>

export function get<T1, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, Index<T5>>>

export function get<T1, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A3, K4>>

export function get<T1, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, A6>>

export function get<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<A3>, K5>, K6>>

export function get<T1, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<A3>, K5>>>

export function get<T1, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A3>, K5>>

export function get<T1, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<A3>>, K6>>

export function get<T1, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<A3>>>>

export function get<T1, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<Index<A3>>>

export function get<T1, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, KeyAt<T5, K6>>>

export function get<T1, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, Index<T5>>>

export function get<T1, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<A3>>

export function get<T1, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, A6>>

export function get<T1, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<T1, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<KeyAt<T4, K5>>>>

export function get<T1, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<T4, K5>>>

export function get<T1, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<Index<T4>, K6>>>

export function get<T1, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<Index<T4>>>>

export function get<T1, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<T4>>>

export function get<T1, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<T1, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, Index<T5>>>

export function get<T1, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A3>

export function get<T1, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, A6>>

export function get<T1, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<A5, K6>>>

export function get<T1, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<A5>>>

export function get<T1, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A5>>

export function get<T1, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S3, A3, A4, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Indexable<S3>>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>, K5>, K6>>>

export function get<T1, T2, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>, K5>>>>

export function get<T1, T2, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>, K5>>>

export function get<T1, T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>, K6>>>

export function get<T1, T2, K3 extends string, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>>>>

export function get<T1, T2, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>>>

export function get<T1, T2, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>, KeyAt<Unpack<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>, K6>>>>

export function get<T1, T2, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>, Index<Unpack<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>>>>>

export function get<T1, T2, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>>

export function get<T1, T2, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>, Unpack<KeyAt<KeyAt<Unpack<Unpack<S>>, K3>, K4>>, A6>>>

export function get<T1, T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<Index<KeyAt<Unpack<Unpack<S>>, K3>>, K5>, K6>>>

export function get<T1, T2, K3 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<Index<KeyAt<Unpack<Unpack<S>>, K3>>, K5>>>>

export function get<T1, T2, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<KeyAt<Unpack<Unpack<S>>, K3>>, K5>>>

export function get<T1, T2, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K3 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<Index<KeyAt<Unpack<Unpack<S>>, K3>>>, K6>>>

export function get<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<Index<KeyAt<Unpack<Unpack<S>>, K3>>>>>>

export function get<T1, T2, K3 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<KeyAt<Unpack<Unpack<S>>, K3>>>>>

export function get<T1, T2, K3 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<KeyAt<Unpack<Unpack<S>>, K3>>, Unpack<Index<KeyAt<Unpack<Unpack<S>>, K3>>>, KeyAt<Unpack<Index<KeyAt<Unpack<Unpack<S>>, K3>>>, K6>>>>

export function get<T1, T2, K3 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<KeyAt<Unpack<Unpack<S>>, K3>>, Unpack<Index<KeyAt<Unpack<Unpack<S>>, K3>>>, Index<Unpack<Index<KeyAt<Unpack<Unpack<S>>, K3>>>>>>>

export function get<T1, T2, K3 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<Unpack<Unpack<S>>, K3>>>>

export function get<T1, T2, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<KeyAt<Unpack<Unpack<S>>, K3>>, Unpack<Index<KeyAt<Unpack<Unpack<S>>, K3>>>, A6>>>

export function get<T1, T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, KeyAt<KeyAt<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, K5>, K6>>>>

export function get<T1, T2, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Index<KeyAt<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, K5>>>>>

export function get<T1, T2, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, KeyAt<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, K5>>>>

export function get<T1, T2, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, A6>>>

export function get<T1, T2, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, KeyAt<Index<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>>, K6>>>>

export function get<T1, T2, K3 extends string, T4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Index<Index<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>>>>>>

export function get<T1, T2, K3 extends string, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Index<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>>>>>

export function get<T1, T2, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, A6>>>

export function get<T1, T2, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Functor<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Unpack<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>>, KeyAt<Unpack<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>>, K6>>>>>

export function get<T1, T2, K3 extends string, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Functor<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Unpack<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>>, Index<Unpack<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>>>>>>>

export function get<T1, T2, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Unpack<Unpack<S>>, K3>>>

export function get<T1, T2, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Functor<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Unpack<Unpack<KeyAt<Unpack<Unpack<S>>, K3>>>, A6>>>>

export function get<T1, T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, KeyAt<A5, K6>>>>

export function get<T1, T2, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, Index<A5>>>>

export function get<T1, T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, A5>>>

export function get<T1, T2, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Unpack<Unpack<S>>, K3>, Unpack<KeyAt<Unpack<Unpack<S>>, K3>>, A6>>>

export function get<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<A4, K5>>>>

export function get<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A4, K5>>>

export function get<T1, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<A4>, K6>>>

export function get<T1, T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<A4>>>>

export function get<T1, T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A4>>>

export function get<T1, T2, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, KeyAt<T5, K6>>>

export function get<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, Index<T5>>>

export function get<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A4>>

export function get<T1, T2, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, A6>>

export function get<T1, T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<KeyAt<Index<Unpack<Unpack<S>>>, K4>, K5>, K6>>>

export function get<T1, T2, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<KeyAt<Index<Unpack<Unpack<S>>>, K4>, K5>>>>

export function get<T1, T2, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<Index<Unpack<Unpack<S>>>, K4>, K5>>>

export function get<T1, T2, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<KeyAt<Index<Unpack<Unpack<S>>>, K4>>, K6>>>

export function get<T1, T2, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<KeyAt<Index<Unpack<Unpack<S>>>, K4>>>>>

export function get<T1, T2, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<Index<Unpack<Unpack<S>>>, K4>>>>

export function get<T1, T2, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Index<Unpack<Unpack<S>>>, K4>, Unpack<KeyAt<Index<Unpack<Unpack<S>>>, K4>>, KeyAt<Unpack<KeyAt<Index<Unpack<Unpack<S>>>, K4>>, K6>>>>

export function get<T1, T2, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Index<Unpack<Unpack<S>>>, K4>, Unpack<KeyAt<Index<Unpack<Unpack<S>>>, K4>>, Index<Unpack<KeyAt<Index<Unpack<Unpack<S>>>, K4>>>>>>

export function get<T1, T2, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<Unpack<Unpack<S>>>, K4>>>

export function get<T1, T2, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<KeyAt<Index<Unpack<Unpack<S>>>, K4>, Unpack<KeyAt<Index<Unpack<Unpack<S>>>, K4>>, A6>>>

export function get<T1, T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<Index<Index<Unpack<Unpack<S>>>>, K5>, K6>>>

export function get<T1, T2, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<Index<Index<Unpack<Unpack<S>>>>, K5>>>>

export function get<T1, T2, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<Index<Unpack<Unpack<S>>>>, K5>>>

export function get<T1, T2, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<Index<Index<Unpack<Unpack<S>>>>>, K6>>>

export function get<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<Index<Index<Unpack<Unpack<S>>>>>>>>

export function get<T1, T2, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<Index<Unpack<Unpack<S>>>>>>>

export function get<T1, T2, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Index<Unpack<Unpack<S>>>>, Unpack<Index<Index<Unpack<Unpack<S>>>>>, KeyAt<Unpack<Index<Index<Unpack<Unpack<S>>>>>, K6>>>>

export function get<T1, T2, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Index<Unpack<Unpack<S>>>>, Unpack<Index<Index<Unpack<Unpack<S>>>>>, Index<Unpack<Index<Index<Unpack<Unpack<S>>>>>>>>>

export function get<T1, T2, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<Unpack<Unpack<S>>>>>>

export function get<T1, T2, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Index<Unpack<Unpack<S>>>>, Unpack<Index<Index<Unpack<Unpack<S>>>>>, A6>>>

export function get<T1, T2, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, KeyAt<KeyAt<Unpack<Index<Unpack<Unpack<S>>>>, K5>, K6>>>>

export function get<T1, T2, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, Index<KeyAt<Unpack<Index<Unpack<Unpack<S>>>>, K5>>>>>

export function get<T1, T2, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, KeyAt<Unpack<Index<Unpack<Unpack<S>>>>, K5>>>>

export function get<T1, T2, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, A6>>>

export function get<T1, T2, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, KeyAt<Index<Unpack<Index<Unpack<Unpack<S>>>>>, K6>>>>

export function get<T1, T2, T4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, Index<Index<Unpack<Index<Unpack<Unpack<S>>>>>>>>>

export function get<T1, T2, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, Index<Unpack<Index<Unpack<Unpack<S>>>>>>>>

export function get<T1, T2, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, A6>>>

export function get<T1, T2, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, Functor<Unpack<Index<Unpack<Unpack<S>>>>, Unpack<Unpack<Index<Unpack<Unpack<S>>>>>, KeyAt<Unpack<Unpack<Index<Unpack<Unpack<S>>>>>, K6>>>>>

export function get<T1, T2, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, Functor<Unpack<Index<Unpack<Unpack<S>>>>, Unpack<Unpack<Index<Unpack<Unpack<S>>>>>, Index<Unpack<Unpack<Index<Unpack<Unpack<S>>>>>>>>>>

export function get<T1, T2, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Unpack<Unpack<S>>>>>

export function get<T1, T2, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, Functor<Unpack<Index<Unpack<Unpack<S>>>>, Unpack<Unpack<Index<Unpack<Unpack<S>>>>>, A6>>>>

export function get<T1, T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, KeyAt<A5, K6>>>>

export function get<T1, T2, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, Index<A5>>>>

export function get<T1, T2, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, A5>>>

export function get<T1, T2, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Index<Unpack<Unpack<S>>>, Unpack<Index<Unpack<Unpack<S>>>>, A6>>>

export function get<T1, T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<T1, T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<A4, K5>>>>

export function get<T1, T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A4, K5>>>

export function get<T1, T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<A4>, K6>>>

export function get<T1, T2, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<A4>>>>

export function get<T1, T2, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A4>>>

export function get<T1, T2, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, KeyAt<T5, K6>>>

export function get<T1, T2, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, Index<T5>>>

export function get<T1, T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A4>>

export function get<T1, T2, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, A6>>

export function get<T1, T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<KeyAt<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>, K5>, K6>>>>

export function get<T1, T2, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<KeyAt<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>, K5>>>>>

export function get<T1, T2, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>, K5>>>>

export function get<T1, T2, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<Index<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>, K6>>>>

export function get<T1, T2, T3, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<Index<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>>>>>

export function get<T1, T2, T3, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>>>>

export function get<T1, T2, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>, Unpack<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>, KeyAt<Unpack<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>, K6>>>>>

export function get<T1, T2, T3, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>, Unpack<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>, Index<Unpack<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>>>>>>

export function get<T1, T2, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>>>

export function get<T1, T2, T3, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>, Unpack<KeyAt<Unpack<Unpack<Unpack<S>>>, K4>>, A6>>>>

export function get<T1, T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<A5, K6>>>>

export function get<T1, T2, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<A5>>>>

export function get<T1, T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A5>>>

export function get<T1, T2, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<KeyAt<Index<Unpack<Unpack<Unpack<S>>>>, K5>, K6>>>>

export function get<T1, T2, T3, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<KeyAt<Index<Unpack<Unpack<Unpack<S>>>>, K5>>>>>

export function get<T1, T2, T3, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<Index<Unpack<Unpack<Unpack<S>>>>, K5>>>>

export function get<T1, T2, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, T3, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<Index<Index<Unpack<Unpack<Unpack<S>>>>>, K6>>>>

export function get<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<Index<Index<Unpack<Unpack<Unpack<S>>>>>>>>>

export function get<T1, T2, T3, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<Index<Unpack<Unpack<Unpack<S>>>>>>>>

export function get<T1, T2, T3, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, T3, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Index<Unpack<Unpack<Unpack<S>>>>, Unpack<Index<Unpack<Unpack<Unpack<S>>>>>, KeyAt<Unpack<Index<Unpack<Unpack<Unpack<S>>>>>, K6>>>>>

export function get<T1, T2, T3, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Index<Unpack<Unpack<Unpack<S>>>>, Unpack<Index<Unpack<Unpack<Unpack<S>>>>>, Index<Unpack<Index<Unpack<Unpack<Unpack<S>>>>>>>>>>

export function get<T1, T2, T3, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<Unpack<Unpack<Unpack<S>>>>>>>

export function get<T1, T2, T3, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Index<Unpack<Unpack<Unpack<S>>>>, Unpack<Index<Unpack<Unpack<Unpack<S>>>>>, A6>>>>

export function get<T1, T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<A5, K6>>>>

export function get<T1, T2, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<A5>>>>

export function get<T1, T2, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A5>>>

export function get<T1, T2, T3, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, KeyAt<KeyAt<Unpack<Unpack<Unpack<Unpack<S>>>>, K5>, K6>>>>>

export function get<T1, T2, T3, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, Index<KeyAt<Unpack<Unpack<Unpack<Unpack<S>>>>, K5>>>>>>

export function get<T1, T2, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, KeyAt<Unpack<Unpack<Unpack<Unpack<S>>>>, K5>>>>>

export function get<T1, T2, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, A6>>>>

export function get<T1, T2, T3, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, KeyAt<Index<Unpack<Unpack<Unpack<Unpack<S>>>>>, K6>>>>>

export function get<T1, T2, T3, T4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, Index<Index<Unpack<Unpack<Unpack<Unpack<S>>>>>>>>>>

export function get<T1, T2, T3, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, Index<Unpack<Unpack<Unpack<Unpack<S>>>>>>>>>

export function get<T1, T2, T3, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, A6>>>>

export function get<T1, T2, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, Functor<Unpack<Unpack<Unpack<Unpack<S>>>>, Unpack<Unpack<Unpack<Unpack<Unpack<S>>>>>, KeyAt<Unpack<Unpack<Unpack<Unpack<Unpack<S>>>>>, K6>>>>>>

export function get<T1, T2, T3, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, Functor<Unpack<Unpack<Unpack<Unpack<S>>>>, Unpack<Unpack<Unpack<Unpack<Unpack<S>>>>>, Index<Unpack<Unpack<Unpack<Unpack<Unpack<S>>>>>>>>>>>

export function get<T1, T2, T3, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>>>(s: S) => S

export function get<T1, T2, T3, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, Functor<Unpack<Unpack<Unpack<Unpack<S>>>>, Unpack<Unpack<Unpack<Unpack<Unpack<S>>>>>, A6>>>>>

export function get<T1, T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, KeyAt<A5, K6>>>>>

export function get<T1, T2, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, Index<A5>>>>>

export function get<T1, T2, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, A5>>>>

export function get<T1, T2, T3, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Functor<Unpack<Unpack<Unpack<S>>>, Unpack<Unpack<Unpack<Unpack<S>>>>, A6>>>>

export function get<T1, T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<KeyAt<A4, K5>, K6>>>>

export function get<T1, T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<KeyAt<A4, K5>>>>>

export function get<T1, T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<A4, K5>>>>

export function get<T1, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<Index<A4>, K6>>>>

export function get<T1, T2, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<Index<A4>>>>>

export function get<T1, T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<A4>>>>

export function get<T1, T2, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A4>>, T5, KeyAt<T5, K6>>>

export function get<T1, T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A4>>, T5, Index<T5>>>

export function get<T1, T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A4>>>

export function get<T1, T2, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A4>>, T5, A6>>

export function get<T1, T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, KeyAt<A5, K6>>>>

export function get<T1, T2, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, Index<A5>>>>

export function get<T1, T2, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A5>>>

export function get<T1, T2, T3, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Functor<Unpack<Unpack<S>>, Unpack<Unpack<Unpack<S>>>, A6>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<KeyAt<A3, K4>, K5>>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<A3, K4>, K5>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<KeyAt<A3, K4>>, K6>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<KeyAt<A3, K4>>>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<A3, K4>>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A3, K4>>, T5, KeyAt<T5, K6>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A3, K4>>, T5, Index<T5>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A3, K4>>>

export function get<T1, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A3, K4>>, T5, A6>>

export function get<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<Index<A3>, K5>, K6>>>

export function get<T1, T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<Index<A3>, K5>>>>

export function get<T1, T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<A3>, K5>>>

export function get<T1, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<Index<A3>>, K6>>>

export function get<T1, T2, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<Index<A3>>>>>

export function get<T1, T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<A3>>>>

export function get<T1, T2, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A3>>, T5, KeyAt<T5, K6>>>

export function get<T1, T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A3>>, T5, Index<T5>>>

export function get<T1, T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A3>>>

export function get<T1, T2, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A3>>, T5, A6>>

export function get<T1, T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, Index<KeyAt<T4, K5>>>>

export function get<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, KeyAt<T4, K5>>>

export function get<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, A6>>

export function get<T1, T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, KeyAt<Index<T4>, K6>>>

export function get<T1, T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, Index<Index<T4>>>>

export function get<T1, T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, Index<T4>>>

export function get<T1, T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, A6>>

export function get<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, T4>, T5, Index<T5>>>

export function get<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A3>>

export function get<T1, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, T4>, T5, A6>>

export function get<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, KeyAt<A5, K6>>>

export function get<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, Index<A5>>>

export function get<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, A5>>

export function get<T1, T2, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A3>, T4, A6>>

export function get<T1, T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<T1, T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<KeyAt<A4, K5>>>>

export function get<T1, T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A4, K5>>>

export function get<T1, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<Index<A4>, K6>>>

export function get<T1, T2, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<Index<A4>>>>

export function get<T1, T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A4>>>

export function get<T1, T2, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, KeyAt<T5, K6>>>

export function get<T1, T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, Index<T5>>>

export function get<T1, T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A4>>

export function get<T1, T2, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Unpack<S>, Unpack<Unpack<S>>, A4>, T5, A6>>

export function get<T1, T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, KeyAt<A5, K6>>>

export function get<T1, T2, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, Index<A5>>>

export function get<T1, T2, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A5>>

export function get<T1, T2, S3, A3, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => Functor<S, Unpack<S>, Functor<Unpack<S>, Unpack<Unpack<S>>, A6>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<A2, K3>, K4>>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, Index<T5>>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A2, K3>, K4>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, A6>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<A2, K3>>, K5>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<KeyAt<A2, K3>>>>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<A2, K3>>>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<A2, K3>>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<A2, K3>>, T5, Index<T5>>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A2, K3>>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<KeyAt<A2, K3>>, T5, A6>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, Index<KeyAt<T4, K5>>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, KeyAt<T4, K5>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, A6>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, KeyAt<Index<T4>, K6>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, Index<Index<T4>>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, Index<T4>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, A6>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<KeyAt<A2, K3>, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<KeyAt<A2, K3>, T4, T4>, T5, Index<T5>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A2, K3>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<KeyAt<A2, K3>, T4, T4>, T5, A6>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, KeyAt<A5, K6>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, Index<A5>>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, A5>>

export function get<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A2, K3>, T4, A6>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<A2>, K4>, K5>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<Index<A2>, K4>>>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<A2>, K4>>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<A2>, K4>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<A2>, K4>, T5, Index<T5>>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A2>, K4>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<Index<A2>, K4>, T5, A6>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>>

export function get<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<Index<A2>>, K5>>>

export function get<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<A2>>, K5>>

export function get<T1, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<Index<A2>>>, K6>>

export function get<T1, S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<Index<A2>>>>>

export function get<T1, S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<A2>>>>

export function get<T1, S2, A2 extends Indexable<Indexable<Indexable>>, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<A2>>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<A2>>, T5, Index<T5>>>

export function get<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<A2>>>

export function get<T1, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<Index<A2>>, T5, A6>>

export function get<T1, S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2 extends Indexable<Indexable>, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, Index<KeyAt<T4, K5>>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, KeyAt<T4, K5>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, A6>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, KeyAt<Index<T4>, K6>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, Index<Index<T4>>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, Index<T4>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, A6>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Index<A2>, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Index<A2>, T4, T4>, T5, Index<T5>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A2>>

export function get<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Index<A2>, T4, T4>, T5, A6>>

export function get<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, KeyAt<A5, K6>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, Index<A5>>>

export function get<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, A5>>

export function get<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A2>, T4, A6>>

export function get<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, S2, A2 extends Indexable, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2 extends Indexable, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2 extends Indexable, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<KeyAt<KeyAt<T3, K4>, K5>, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<KeyAt<KeyAt<T3, K4>, K5>>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<KeyAt<T3, K4>, K5>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<Index<KeyAt<T3, K4>>, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<Index<KeyAt<T3, K4>>>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<KeyAt<T3, K4>>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, KeyAt<T3, K4>>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, KeyAt<T3, K4>>, T5, Index<T5>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<T3, K4>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, KeyAt<T3, K4>>, T5, A6>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<A5, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<A5>>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A5>>

export function get<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<KeyAt<Index<T3>, K5>, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<KeyAt<Index<T3>, K5>>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<Index<T3>, K5>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<Index<Index<T3>>, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<Index<Index<T3>>>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<Index<T3>>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, Index<T3>>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, Index<T3>>, T5, Index<T5>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<T3>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, Index<T3>>, T5, A6>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<A5, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<A5>>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A5>>

export function get<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, Index<KeyAt<T4, K5>>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, KeyAt<T4, K5>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, A6>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, KeyAt<Index<T4>, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, Index<Index<T4>>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, Index<T4>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, A6>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Functor<A2, T3, T3>, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Functor<A2, T3, T3>, T4, T4>, T5, Index<T5>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A2>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<Functor<A2, T3, T3>, T4, T4>, T5, A6>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, KeyAt<A5, K6>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, Index<A5>>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, A5>>

export function get<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, T3>, T4, A6>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<KeyAt<A4, K5>>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<A4, K5>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<Index<A4>, K6>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<Index<A4>>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<A4>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, A4>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, A4>, T5, Index<T5>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A4>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A2, T3, A4>, T5, A6>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, KeyAt<A5, K6>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, Index<A5>>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A5>>

export function get<T1, S2, A2 extends Collection<T3>, T3, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A2, T3, A6>>

export function get<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>>

export function get<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<KeyAt<A3, K4>, K5>>>

export function get<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A3, K4>, K5>>

export function get<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<KeyAt<A3, K4>>, K6>>

export function get<T1, S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<KeyAt<A3, K4>>>>

export function get<T1, S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A3, K4>>>

export function get<T1, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, Index<T5>>>

export function get<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A3, K4>>

export function get<T1, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<KeyAt<A3, K4>, T5, A6>>

export function get<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<Index<A3>, K5>, K6>>

export function get<T1, S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<Index<A3>, K5>>>

export function get<T1, S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A3>, K5>>

export function get<T1, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<Index<A3>>, K6>>

export function get<T1, S2, A2, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<Index<A3>>>>

export function get<T1, S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<A3>>>

export function get<T1, S2, A2, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, Index<T5>>>

export function get<T1, S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A3>>

export function get<T1, S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Index<A3>, T5, A6>>

export function get<T1, S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<KeyAt<T4, K5>>>>

export function get<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<T4, K5>>>

export function get<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<Index<T4>, K6>>>

export function get<T1, S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<Index<T4>>>>

export function get<T1, S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<T4>>>

export function get<T1, S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, Index<T5>>>

export function get<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A3>

export function get<T1, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<Functor<A3, T4, T4>, T5, A6>>

export function get<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, KeyAt<A5, K6>>>

export function get<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, Index<A5>>>

export function get<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A5>>

export function get<T1, S2, A2, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A3, T4, A6>>

export function get<T1, S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<KeyAt<A4, K5>, K6>>

export function get<T1, S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<KeyAt<A4, K5>>>

export function get<T1, S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A4, K5>>

export function get<T1, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<Index<A4>, K6>>

export function get<T1, S2, A2, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<Index<A4>>>

export function get<T1, S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A4>>

export function get<T1, S2, A2, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<T1, S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<T1, S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, Index<T5>>>

export function get<T1, S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A4>

export function get<T1, S2, A2, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Functor<A4, T5, A6>>

export function get<T1, S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, KeyAt<A5, K6>>

export function get<T1, S2, A2, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, Index<A5>>

export function get<T1, S2, A2, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A5>

export function get<T1, S2, A2, A3, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): <S extends Collection<T1 & S2>>(s: S) => Functor<S, Unpack<S>, A6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, K2 extends string, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable>>>, K2 extends string, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5>>>>, K2 extends string, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, T5, A6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5>>>>, K2 extends string, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable>>>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable>>>, K2 extends string, K3 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<KeyAt<KeyAt<A1, K2>, K3>>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<KeyAt<KeyAt<A1, K2>, K3>>, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<KeyAt<KeyAt<A1, K2>, K3>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5>>>>, K2 extends string, K3 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<KeyAt<KeyAt<A1, K2>, K3>>, T5, A6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5>>>>, K2 extends string, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, A6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, K2 extends string, K3 extends string, T4>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, Index<Index<T4>>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, T4, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, Index<T4>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable>>>, K2 extends string, K3 extends string, T4, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, A6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<A1, K2>, K3>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5>>>>, K2 extends string, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, Functor<T4, T5, A6>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, KeyAt<A5, K6>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, Index<A5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, A5>

export function get<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<KeyAt<KeyAt<A1, K2>, K3>, T4, A6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>, K6>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5>>>>, K2 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>, K6>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable>>>>, K2 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable>>>, K2 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<Index<KeyAt<A1, K2>>, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<Index<KeyAt<A1, K2>>, K4>, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<Index<KeyAt<A1, K2>>, K4>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5>>>>, K2 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<Index<KeyAt<A1, K2>>, K4>, T5, A6>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>, K6>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable>>>>, K2 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5>>>>, K2 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<Index<KeyAt<A1, K2>>>>, K6>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<Indexable>>>>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<Index<KeyAt<A1, K2>>>>>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<Collection<T6>>>>>, K2 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<Index<KeyAt<A1, K2>>>>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable>>>, K2 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<KeyAt<A1, K2>>>>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<Index<KeyAt<A1, K2>>>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable>>>>, K2 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<Index<KeyAt<A1, K2>>>, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<Index<KeyAt<A1, K2>>>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5>>>>, K2 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<Index<KeyAt<A1, K2>>>, T5, A6>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5>>>>, K2 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, A6>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable>>>>, K2 extends string, T4>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, Index<Index<T4>>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, T4, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, Index<T4>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable>>>, K2 extends string, T4, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, A6>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<KeyAt<A1, K2>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5>>>>, K2 extends string, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, Functor<T4, T5, A6>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, KeyAt<A5, K6>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, Index<A5>>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, A5>

export function get<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<Index<KeyAt<A1, K2>>, T4, A6>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<KeyAt<KeyAt<T3, K4>, K5>, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<KeyAt<KeyAt<T3, K4>, K5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<KeyAt<T3, K4>, K5>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5>>>>, K2 extends string, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<Index<KeyAt<T3, K4>>, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, K2 extends string, T3, K4 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<Index<KeyAt<T3, K4>>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, T3, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<KeyAt<T3, K4>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable>>>, K2 extends string, T3, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<KeyAt<T3, K4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, T3, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<KeyAt<T3, K4>, T5, Index<T5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<T3, K4>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5>>>>, K2 extends string, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<KeyAt<T3, K4>, T5, A6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<A5, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<A5>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A5>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<KeyAt<Index<T3>, K5>, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, K2 extends string, T3, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<KeyAt<Index<T3>, K5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<Index<T3>, K5>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5>>>>, K2 extends string, T3, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, T3, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<Index<Index<T3>>, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable>>>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<Index<Index<T3>>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, K2 extends string, T3, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<Index<T3>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable>>>, K2 extends string, T3, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<Index<T3>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, K2 extends string, T3, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<Index<T3>, T5, Index<T5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<T3>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>, K2 extends string, T3, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<Index<T3>, T5, A6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<A5, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<A5>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A5>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, T3, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, Index<KeyAt<T4, K5>>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5>>>>, K2 extends string, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, A6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, T3, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, KeyAt<Index<T4>, K6>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, K2 extends string, T3, T4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, Index<Index<T4>>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, T3, T4, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, Index<T4>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable>>>, K2 extends string, T3, T4, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, A6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<Functor<T3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, T3, T4, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<Functor<T3, T4, T4>, T5, Index<T5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<A1, K2>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5>>>>, K2 extends string, T3, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<Functor<T3, T4, T4>, T5, A6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, KeyAt<A5, K6>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, Index<A5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, A5>>

export function get<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<T3, T4, A6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<KeyAt<A4, K5>, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<KeyAt<A4, K5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<A4, K5>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<Index<A4>, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<Index<A4>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<A4>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<A4, T5, Index<T5>>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A4>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, Functor<A4, T5, A6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => Functor<KeyAt<A1, K2>, T3, KeyAt<A5, K6>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Functor<KeyAt<A1, K2>, T3, Index<A5>>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A5>

export function get<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<KeyAt<A1, K2>, T3, A6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<A3, K4>, K5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<A3, K4>>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<A3, K4>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<A3, K4>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<A3>, K5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<A3>, K5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<A3>>, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<A3>>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<A3>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<A3>, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<A3>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<A3>, T5, A6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<A3, T4, Index<Index<T4>>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, Index<T4>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A3

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<A3, T4, Index<A5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, A5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>, K6>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5>>>>, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>, K6>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable>>>, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<KeyAt<Index<A1>, K3>, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<KeyAt<Index<A1>, K3>, K4>, T5, Index<T5>>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<Index<A1>, K3>, K4>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5>>>>, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<KeyAt<Index<A1>, K3>, K4>, T5, A6>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>, K6>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5>>>>, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<KeyAt<Index<A1>, K3>>>, K6>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<Indexable>>>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<KeyAt<Index<A1>, K3>>>>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, K3 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<KeyAt<Index<A1>, K3>>>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable>>>, K3 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<Index<A1>, K3>>>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<KeyAt<Index<A1>, K3>>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, K3 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<KeyAt<Index<A1>, K3>>, T5, Index<T5>>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, K3 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<KeyAt<Index<A1>, K3>>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5>>>>, K3 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<KeyAt<Index<A1>, K3>>, T5, A6>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5>>>>, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, A6>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, K3 extends string, T4>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, Index<Index<T4>>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, K3 extends string, T4, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, Index<T4>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable>>>, K3 extends string, T4, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, A6>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<Index<A1>, K3>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5>>>>, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, Functor<T4, T5, A6>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, KeyAt<A5, K6>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, Index<A5>>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, A5>

export function get<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<KeyAt<Index<A1>, K3>, T4, A6>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>, K6>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5>>>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<Index<Index<A1>>, K4>>, K6>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<Indexable>>>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<Index<Index<A1>>, K4>>>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<Index<Index<A1>>, K4>>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable>>>, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<Index<A1>>, K4>>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<Index<Index<A1>>, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<Index<Index<A1>>, K4>, T5, Index<T5>>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<Index<Index<A1>>, K4>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5>>>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<Index<Index<A1>>, K4>, T5, A6>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<Index<Index<A1>>>, K5>, K6>

export function get<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, Indexable>>>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<Index<Index<A1>>>, K5>>

export function get<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<Index<Index<A1>>>, K5>

export function get<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5>>>>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<Index<A1>>>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable<Indexable<Indexable<HasKey<K6>>>>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<Index<Index<A1>>>>, K6>

export function get<S1, A1 extends Indexable<Indexable<Indexable<Indexable<Indexable>>>>>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<Index<Index<A1>>>>>

export function get<S1, A1 extends Indexable<Indexable<Indexable<Indexable<Collection<T6>>>>>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<Index<Index<A1>>>>

export function get<S1, A1 extends Indexable<Indexable<Indexable<Indexable>>>, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<Index<A1>>>>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<Index<Index<A1>>>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & Indexable>>>>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<Index<Index<A1>>>, T5, Index<T5>>

export function get<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<Index<Index<A1>>>

export function get<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5>>>>, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<Index<Index<A1>>>, T5, A6>

export function get<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable<Indexable<Indexable>>, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<Index<Index<A1>>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<Index<Index<A1>>, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<Index<Index<A1>>, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5>>>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<Index<Index<A1>>, T4, A6>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<Index<Index<A1>>, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<Indexable>>>>, T4>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<Index<Index<A1>>, T4, Index<Index<T4>>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, T4, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<Index<Index<A1>>, T4, Index<T4>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable>>>, T4, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<Index<Index<A1>>, T4, A6>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<Index<A1>>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, T4, T5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<Index<A1>>, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<Index<A1>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5>>>>, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<Index<A1>>, T4, Functor<T4, T5, A6>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<Index<Index<A1>>, T4, KeyAt<A5, K6>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<Index<Index<A1>>, T4, Index<A5>>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<Index<Index<A1>>, T4, A5>

export function get<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<Index<Index<A1>>, T4, A6>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1 extends Indexable<Indexable>, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable<Indexable>, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable<Indexable>, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable<Indexable>, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<KeyAt<KeyAt<T3, K4>, K5>, K6>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<KeyAt<KeyAt<T3, K4>, K5>>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, KeyAt<KeyAt<T3, K4>, K5>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5>>>>, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<Index<KeyAt<T3, K4>>, K6>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<Index<KeyAt<T3, K4>>>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, T3, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, Index<KeyAt<T3, K4>>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable>>>, T3, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<A1>, T3, Functor<KeyAt<T3, K4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<A1>, T3, Functor<KeyAt<T3, K4>, T5, Index<T5>>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, KeyAt<T3, K4>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5>>>>, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<A1>, T3, Functor<KeyAt<T3, K4>, T5, A6>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<A5, K6>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<A5>>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, A5>

export function get<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<KeyAt<Index<T3>, K5>, K6>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, T3, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<KeyAt<Index<T3>, K5>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, T3, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, KeyAt<Index<T3>, K5>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5>>>>, T3, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, T3, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<Index<Index<T3>>, K6>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<Indexable>>>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<Index<Index<T3>>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, T3, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, Index<Index<T3>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable>>>, T3, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, T3, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<A1>, T3, Functor<Index<T3>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, T3, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<A1>, T3, Functor<Index<T3>, T5, Index<T5>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, T3, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, Index<T3>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5>>>>, T3, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<A1>, T3, Functor<Index<T3>, T5, A6>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<A5, K6>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<A5>>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, A5>

export function get<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, Index<KeyAt<T4, K5>>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5>>>>, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, A6>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, T3, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, KeyAt<Index<T4>, K6>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, T3, T4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, Index<Index<T4>>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, T3, T4, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, Index<T4>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable>>>, T3, T4, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, A6>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<A1>, T3, Functor<Functor<T3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, T3, T4, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<A1>, T3, Functor<Functor<T3, T4, T4>, T5, Index<T5>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, T3, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<A1>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5>>>>, T3, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<A1>, T3, Functor<Functor<T3, T4, T4>, T5, A6>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, KeyAt<A5, K6>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, Index<A5>>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, A5>>

export function get<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<Index<A1>, T3, Functor<T3, T4, A6>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<KeyAt<A4, K5>, K6>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<KeyAt<A4, K5>>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, KeyAt<A4, K5>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<Index<A4>, K6>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<Index<A4>>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, Index<A4>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<A1>, T3, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<A1>, T3, Functor<A4, T5, Index<T5>>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, A4>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<A1>, T3, Functor<A4, T5, A6>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => Functor<Index<A1>, T3, KeyAt<A5, K6>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Functor<Index<A1>, T3, Index<A5>>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => Functor<Index<A1>, T3, A5>

export function get<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<Index<A1>, T3, A6>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<A3, K4>, K5>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<A3, K4>>>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<A3, K4>>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<A3, K4>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<A3>, K5>>

export function get<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<A3>, K5>

export function get<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<A3>>, K6>

export function get<S1, A1 extends Indexable, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<A3>>>

export function get<S1, A1 extends Indexable, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<A3>>

export function get<S1, A1 extends Indexable, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<A3>, T5, Index<T5>>

export function get<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<A3>

export function get<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<A3>, T5, A6>

export function get<S1, A1 extends Indexable, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<A3, T4, Index<Index<T4>>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, Index<T4>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A3

export function get<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<A3, T4, Index<A5>>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, A5>

export function get<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1 extends Indexable, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1 extends Indexable, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1 extends Indexable, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1 extends Indexable, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1 extends Indexable, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1 extends Indexable, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1 extends Indexable, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1 extends Indexable, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1 extends Indexable, A3, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<KeyAt<KeyAt<T2, K3>, K4>, K5>, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, T2, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<KeyAt<KeyAt<T2, K3>, K4>, K5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<KeyAt<T2, K3>, K4>, K5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5>>>>, T2, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<T2, K3>, K4>, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<KeyAt<KeyAt<T2, K3>, K4>>, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, T2, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<KeyAt<KeyAt<T2, K3>, K4>>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, T2, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<KeyAt<KeyAt<T2, K3>, K4>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable>>>, T2, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<T2, K3>, K4>>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<KeyAt<KeyAt<T2, K3>, K4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, T2, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<KeyAt<KeyAt<T2, K3>, K4>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<T2, K3>, K4>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5>>>>, T2, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<KeyAt<T2, K3>, K4>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<Index<KeyAt<T2, K3>>, K5>, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, T2, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<Index<KeyAt<T2, K3>>, K5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<Index<KeyAt<T2, K3>>, K5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5>>>>, T2, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<T2, K3>>, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, T2, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<Index<KeyAt<T2, K3>>>, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable>>>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<Index<KeyAt<T2, K3>>>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, T2, K3 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<Index<KeyAt<T2, K3>>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable>>>, T2, K3 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<T2, K3>>>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Index<KeyAt<T2, K3>>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, T2, K3 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Index<KeyAt<T2, K3>>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<KeyAt<T2, K3>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5>>>>, T2, K3 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Index<KeyAt<T2, K3>>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, T2, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, Index<KeyAt<T4, K5>>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5>>>>, T2, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, T2, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, KeyAt<Index<T4>, K6>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, T2, K3 extends string, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, Index<Index<T4>>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, T2, K3 extends string, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, Index<T4>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable>>>, T2, K3 extends string, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<KeyAt<T2, K3>, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, T2, K3 extends string, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<KeyAt<T2, K3>, T4, T4>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<T2, K3>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5>>>>, T2, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<KeyAt<T2, K3>, T4, T4>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, KeyAt<A5, K6>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, Index<A5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, A5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<T2, K3>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<A4, K5>, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<A4, K5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<A4, K5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<A4>, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<A4>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<A4>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<A4, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A4>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<A4, T5, A6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<KeyAt<Index<T2>, K4>, K5>, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, T2, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<KeyAt<Index<T2>, K4>, K5>>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<Index<T2>, K4>, K5>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5>>>>, T2, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<T2>, K4>, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, T2, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<KeyAt<Index<T2>, K4>>, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable>>>>, T2, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<KeyAt<Index<T2>, K4>>>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, T2, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<KeyAt<Index<T2>, K4>>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable>>>, T2, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<T2>, K4>>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<KeyAt<Index<T2>, K4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, T2, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<KeyAt<Index<T2>, K4>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<Index<T2>, K4>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5>>>>, T2, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<Index<T2>, K4>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, T2, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<Index<Index<T2>>, K5>, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable>>>>, T2, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<Index<Index<T2>>, K5>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, T2, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<Index<Index<T2>>, K5>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5>>>>, T2, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<T2>>, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6>>>>>, T2, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<Index<Index<T2>>>, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<Indexable>>>>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<Index<Index<T2>>>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<Collection<T6>>>>>, T2, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<Index<Index<T2>>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable>>>, T2, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<T2>>>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, T2, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Index<Index<T2>>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable>>>>, T2, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Index<Index<T2>>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, T2, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<Index<T2>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5>>>>, T2, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Index<Index<T2>>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, T2, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, Index<KeyAt<T4, K5>>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5>>>>, T2, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, T2, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, KeyAt<Index<T4>, K6>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable>>>>, T2, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, Index<Index<T4>>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, T2, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, Index<T4>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable>>>, T2, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<Index<T2>, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, T2, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<Index<T2>, T4, T4>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<T2>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5>>>>, T2, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<Index<T2>, T4, T4>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, KeyAt<A5, K6>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, Index<A5>>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, A5>>

export function get<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, Functor<Index<T2>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<A4, K5>, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<A4, K5>>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<A4, K5>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<A4>, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<A4>>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<A4>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<A4, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A4>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<A4, T5, A6>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<KeyAt<KeyAt<T3, K4>, K5>, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, T2, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<KeyAt<KeyAt<T3, K4>, K5>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<KeyAt<T3, K4>, K5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5>>>>, T2, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, T2, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<Index<KeyAt<T3, K4>>, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, T2, T3, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<Index<KeyAt<T3, K4>>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, T2, T3, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<KeyAt<T3, K4>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable>>>, T2, T3, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, KeyAt<T3, K4>>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, T2, T3, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, KeyAt<T3, K4>>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<T3, K4>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5>>>>, T2, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, KeyAt<T3, K4>>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<A5, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<A5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A5>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, T2, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<KeyAt<Index<T3>, K5>, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, T2, T3, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<KeyAt<Index<T3>, K5>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, T2, T3, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<Index<T3>, K5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5>>>>, T2, T3, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, T2, T3, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<Index<Index<T3>>, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable>>>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<Index<Index<T3>>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, T2, T3, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<Index<T3>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable>>>, T2, T3, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, T2, T3, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, Index<T3>>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, T2, T3, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, Index<T3>>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, T2, T3, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<T3>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5>>>>, T2, T3, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, Index<T3>>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<A5, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<A5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A5>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, T2, T3, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, Index<KeyAt<T4, K5>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5>>>>, T2, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, T2, T3, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, KeyAt<Index<T4>, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, T2, T3, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, Index<Index<T4>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, T2, T3, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, Index<T4>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable>>>, T2, T3, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<Functor<T2, T3, T3>, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, T2, T3, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<Functor<T2, T3, T3>, T4, T4>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, T3, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A1

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5>>>>, T2, T3, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<Functor<T2, T3, T3>, T4, T4>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, KeyAt<A5, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, Index<A5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, A5>>

export function get<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, T3>, T4, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<KeyAt<A4, K5>, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<KeyAt<A4, K5>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<A4, K5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<Index<A4>, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<Index<A4>>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<A4>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, A4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, A4>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A4>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<T2, T3, A4>, T5, A6>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<T2, T3, KeyAt<A5, K6>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Functor<A1, T2, Functor<T2, T3, Index<A5>>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A5>>

export function get<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, Functor<T2, T3, A6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<KeyAt<A3, K4>, K5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<A3, K4>, K5>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<KeyAt<A3, K4>>, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<KeyAt<A3, K4>>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<KeyAt<A3, K4>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<KeyAt<A3, K4>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<A3, K4>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<KeyAt<A3, K4>, T5, A6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<Index<A3>, K5>, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<Index<A3>, K5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<Index<A3>, K5>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<Index<A3>>, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<Index<A3>>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<Index<A3>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Index<A3>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Index<A3>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<A3>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Index<A3>, T5, A6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Functor<A3, T4, Index<KeyAt<T4, K5>>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<A3, T4, KeyAt<T4, K5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<A1, T2, Functor<A3, T4, A6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<A1, T2, Functor<A3, T4, KeyAt<Index<T4>, K6>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<A1, T2, Functor<A3, T4, Index<Index<T4>>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<A3, T4, Index<T4>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<A1, T2, Functor<A3, T4, A6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<Functor<A3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<Functor<A3, T4, T4>, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A3>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<Functor<A3, T4, T4>, T5, A6>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<A3, T4, KeyAt<A5, K6>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<A1, T2, Functor<A3, T4, Index<A5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Functor<A3, T4, A5>>

export function get<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, Functor<A3, T4, A6>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<KeyAt<A4, K5>, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: S1) => Functor<A1, T2, Index<KeyAt<A4, K5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, KeyAt<A4, K5>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<Index<A4>, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: S1) => Functor<A1, T2, Index<Index<A4>>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, Index<A4>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A1, T2, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A1, T2, Functor<A4, T5, Index<T5>>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A4>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A1, T2, Functor<A4, T5, A6>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => Functor<A1, T2, KeyAt<A5, K6>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Functor<A1, T2, Index<A5>>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A1, T2, A5>

export function get<S1, A1 extends Collection<T2>, T2, A3, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A1, T2, A6>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<KeyAt<A2, K3>, K4>>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, Index<T5>>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<A2, K3>, K4>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<KeyAt<A2, K3>, K4>, T5, A6>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<KeyAt<A2, K3>>, K5>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<KeyAt<A2, K3>>>>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<KeyAt<A2, K3>>>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<KeyAt<A2, K3>>, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<KeyAt<A2, K3>>, T5, Index<T5>>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<KeyAt<A2, K3>>

export function get<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<KeyAt<A2, K3>>, T5, A6>

export function get<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<KeyAt<A2, K3>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<KeyAt<A2, K3>, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A2, K3>, T4, KeyAt<T4, K5>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<KeyAt<A2, K3>, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<KeyAt<A2, K3>, T4, Index<Index<T4>>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A2, K3>, T4, Index<T4>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<A2, K3>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<A2, K3>, T4, Functor<T4, T5, A6>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<KeyAt<A2, K3>, T4, KeyAt<A5, K6>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<KeyAt<A2, K3>, T4, Index<A5>>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<KeyAt<A2, K3>, T4, A5>

export function get<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<KeyAt<A2, K3>, T4, A6>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<Index<A2>, K4>, K5>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<Index<A2>, K4>>>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<Index<A2>, K4>>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<Index<A2>, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<Index<A2>, K4>, T5, Index<T5>>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<Index<A2>, K4>

export function get<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<Index<A2>, K4>, T5, A6>

export function get<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>

export function get<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<Index<A2>>, K5>>

export function get<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<Index<A2>>, K5>

export function get<S1, A1, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<Index<A2>>>, K6>

export function get<S1, A1, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<Index<A2>>>>

export function get<S1, A1, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<Index<A2>>>

export function get<S1, A1, A2 extends Indexable<Indexable<Indexable>>, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<Index<A2>>, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<Index<A2>>, T5, Index<T5>>

export function get<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<Index<A2>>

export function get<S1, A1, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<Index<A2>>, T5, A6>

export function get<S1, A1, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2 extends Indexable<Indexable>, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2 extends Indexable<Indexable>, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<Index<A2>, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<Index<A2>, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<Index<A2>, T4, KeyAt<T4, K5>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<Index<A2>, T4, A6>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<Index<A2>, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<Index<A2>, T4, Index<Index<T4>>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<Index<A2>, T4, Index<T4>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<Index<A2>, T4, A6>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<A2>, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<A2>, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<A2>

export function get<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<A2>, T4, Functor<T4, T5, A6>>

export function get<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<Index<A2>, T4, KeyAt<A5, K6>>

export function get<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<Index<A2>, T4, Index<A5>>

export function get<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<Index<A2>, T4, A5>

export function get<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<Index<A2>, T4, A6>

export function get<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1, A2 extends Indexable, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1, A2 extends Indexable, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2 extends Indexable, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2 extends Indexable, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<KeyAt<KeyAt<T3, K4>, K5>, K6>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (s: S1) => Functor<A2, T3, Index<KeyAt<KeyAt<T3, K4>, K5>>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, KeyAt<KeyAt<T3, K4>, K5>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<Index<KeyAt<T3, K4>>, K6>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (s: S1) => Functor<A2, T3, Index<Index<KeyAt<T3, K4>>>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, Index<KeyAt<T3, K4>>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, Index<T5>>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, KeyAt<T3, K4>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A2, T3, Functor<KeyAt<T3, K4>, T5, A6>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (s: S1) => Functor<A2, T3, Index<A5>>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, A5>

export function get<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<KeyAt<Index<T3>, K5>, K6>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (s: S1) => Functor<A2, T3, Index<KeyAt<Index<T3>, K5>>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, KeyAt<Index<T3>, K5>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<Index<Index<T3>>, K6>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (s: S1) => Functor<A2, T3, Index<Index<Index<T3>>>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, Index<Index<T3>>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A2, T3, Functor<Index<T3>, T5, KeyAt<T5, K6>>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A2, T3, Functor<Index<T3>, T5, Index<T5>>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, Index<T3>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A2, T3, Functor<Index<T3>, T5, A6>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (s: S1) => Functor<A2, T3, Index<A5>>

export function get<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, A5>

export function get<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<A2, T3, Functor<T3, T4, KeyAt<KeyAt<T4, K5>, K6>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<A2, T3, Functor<T3, T4, Index<KeyAt<T4, K5>>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, Functor<T3, T4, KeyAt<T4, K5>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<A2, T3, Functor<T3, T4, KeyAt<Index<T4>, K6>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<A2, T3, Functor<T3, T4, Index<Index<T4>>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, Functor<T3, T4, Index<T4>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, KeyAt<T5, K6>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, Index<T5>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A2

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A2, T3, Functor<Functor<T3, T4, T4>, T5, A6>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<A2, T3, Functor<T3, T4, KeyAt<A5, K6>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<A2, T3, Functor<T3, T4, Index<A5>>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, Functor<T3, T4, A5>>

export function get<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A2, T3, Functor<T3, T4, A6>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<KeyAt<A4, K5>, K6>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (s: S1) => Functor<A2, T3, Index<KeyAt<A4, K5>>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, KeyAt<A4, K5>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<Index<A4>, K6>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (s: S1) => Functor<A2, T3, Index<Index<A4>>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, Index<A4>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A2, T3, Functor<A4, T5, KeyAt<T5, K6>>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A2, T3, Functor<A4, T5, Index<T5>>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, A4>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A2, T3, Functor<A4, T5, A6>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => Functor<A2, T3, KeyAt<A5, K6>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Functor<A2, T3, Index<A5>>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A2, T3, A5>

export function get<S1, A1, A2 extends Collection<T3>, T3, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A2, T3, A6>

export function get<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>

export function get<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (s: S1) => Index<KeyAt<KeyAt<A3, K4>, K5>>

export function get<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<KeyAt<A3, K4>, K5>

export function get<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (s: S1) => KeyAt<Index<KeyAt<A3, K4>>, K6>

export function get<S1, A1, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (s: S1) => Index<Index<KeyAt<A3, K4>>>

export function get<S1, A1, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (s: S1) => Index<KeyAt<A3, K4>>

export function get<S1, A1, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (s: S1) => A6

export function get<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<KeyAt<A3, K4>, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (s: S1) => Functor<KeyAt<A3, K4>, T5, Index<T5>>

export function get<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => KeyAt<A3, K4>

export function get<S1, A1, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<KeyAt<A3, K4>, T5, A6>

export function get<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<Index<A3>, K5>, K6>

export function get<S1, A1, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (s: S1) => Index<KeyAt<Index<A3>, K5>>

export function get<S1, A1, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<Index<A3>, K5>

export function get<S1, A1, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (s: S1) => KeyAt<Index<Index<A3>>, K6>

export function get<S1, A1, A2, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (s: S1) => Index<Index<Index<A3>>>

export function get<S1, A1, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (s: S1) => Index<Index<A3>>

export function get<S1, A1, A2, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (s: S1) => A6

export function get<S1, A1, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<Index<A3>, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (s: S1) => Functor<Index<A3>, T5, Index<T5>>

export function get<S1, A1, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => Index<A3>

export function get<S1, A1, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<Index<A3>, T5, A6>

export function get<S1, A1, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (s: S1) => A6

export function get<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<KeyAt<T4, K5>, K6>>

export function get<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (s: S1) => Functor<A3, T4, Index<KeyAt<T4, K5>>>

export function get<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, KeyAt<T4, K5>>

export function get<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<Index<T4>, K6>>

export function get<S1, A1, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (s: S1) => Functor<A3, T4, Index<Index<T4>>>

export function get<S1, A1, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, Index<T4>>

export function get<S1, A1, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A3, T4, Functor<T4, T5, KeyAt<T5, K6>>>

export function get<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A3, T4, Functor<T4, T5, Index<T5>>>

export function get<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A3

export function get<S1, A1, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A3, T4, Functor<T4, T5, A6>>

export function get<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (s: S1) => Functor<A3, T4, KeyAt<A5, K6>>

export function get<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (s: S1) => Functor<A3, T4, Index<A5>>

export function get<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (s: S1) => Functor<A3, T4, A5>

export function get<S1, A1, A2, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (s: S1) => Functor<A3, T4, A6>

export function get<S1, A1, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (s: S1) => KeyAt<KeyAt<A4, K5>, K6>

export function get<S1, A1, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (s: S1) => Index<KeyAt<A4, K5>>

export function get<S1, A1, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (s: S1) => KeyAt<A4, K5>

export function get<S1, A1, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (s: S1) => A6

export function get<S1, A1, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (s: S1) => KeyAt<Index<A4>, K6>

export function get<S1, A1, A2, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (s: S1) => Index<Index<A4>>

export function get<S1, A1, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (s: S1) => Index<A4>

export function get<S1, A1, A2, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (s: S1) => A6

export function get<S1, A1, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (s: S1) => Functor<A4, T5, KeyAt<T5, K6>>

export function get<S1, A1, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (s: S1) => Functor<A4, T5, Index<T5>>

export function get<S1, A1, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (s: S1) => A4

export function get<S1, A1, A2, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (s: S1) => Functor<A4, T5, A6>

export function get<S1, A1, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (s: S1) => KeyAt<A5, K6>

export function get<S1, A1, A2, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (s: S1) => Index<A5>

export function get<S1, A1, A2, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (s: S1) => A5

export function get<S1, A1, A2, A3, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (s: S1) => A6


export function set<K1 extends string>(k1: K1): <V>(v: V) => <S extends HasKey<K1, V>>(s: S) => S

export function set(i1: number): <V>(v: V) => <S extends Indexable<V>>(s: S) => S

export function set<T1>(t1: Traversal<T1>): <V>(v: V) => <S extends Collection<T1 & V>>(s: S) => S

export function set<S1, A1>(l1: Lens<S1, A1>): (v: A1) => (s: S1) => S1

export function set<K1 extends string, K2 extends string>(k1: K1, k2: K2): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, V>>>(s: S) => S

export function set<K1 extends string>(k1: K1, i2: number): <V>(v: V) => <S extends HasKey<K1, Indexable<V>>>(s: S) => S

export function set<K1 extends string, T2>(k1: K1, t2: Traversal<T2>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & V>>>(s: S) => S

export function set<K1 extends string, S2, A2>(k1: K1, l2: Lens<S2, A2>): (v: A2) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K2 extends string>(i1: number, k2: K2): <V>(v: V) => <S extends Indexable<HasKey<K2, V>>>(s: S) => S

export function set(i1: number, i2: number): <V>(v: V) => <S extends Indexable<Indexable<V>>>(s: S) => S

export function set<T2>(i1: number, t2: Traversal<T2>): <V>(v: V) => <S extends Indexable<Collection<T2 & V>>>(s: S) => S

export function set<S2, A2>(i1: number, l2: Lens<S2, A2>): (v: A2) => <S extends Indexable<S2>>(s: S) => S

export function set<T1, K2 extends string>(t1: Traversal<T1>, k2: K2): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, V>>>(s: S) => S

export function set<T1>(t1: Traversal<T1>, i2: number): <V>(v: V) => <S extends Collection<T1 & Indexable<V>>>(s: S) => S

export function set<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & V>>>(s: S) => S

export function set<T1, S2, A2>(t1: Traversal<T1>, l2: Lens<S2, A2>): (v: A2) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<S1, A1 extends HasKey<K2>, K2 extends string>(l1: Lens<S1, A1>, k2: K2): (v: KeyAt<A1, K2>) => (s: S1) => S1

export function set<S1, A1 extends Indexable>(l1: Lens<S1, A1>, i2: number): (v: Index<A1>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>): (v: Unpack<A1>) => (s: S1) => S1

export function set<S1, A1, A2>(l1: Lens<S1, A1>, l2: Lens<A1, A2>): (v: A2) => (s: S1) => S1

export function set<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, V>>>>(s: S) => S

export function set<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<V>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & V>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3>(k1: K1, k2: K2, l3: Lens<S3, A3>): (v: A3) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, V>>>>(s: S) => S

export function set<K1 extends string>(k1: K1, i2: number, i3: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<V>>>>(s: S) => S

export function set<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & V>>>>(s: S) => S

export function set<K1 extends string, S3, A3>(k1: K1, i2: number, l3: Lens<S3, A3>): (v: A3) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, V>>>>(s: S) => S

export function set<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<V>>>>(s: S) => S

export function set<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & V>>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>): (v: A3) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3): (v: KeyAt<A2, K3>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number): (v: Index<A2>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>): (v: Unpack<A2>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>): (v: A3) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, V>>>>(s: S) => S

export function set<K2 extends string>(i1: number, k2: K2, i3: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<V>>>>(s: S) => S

export function set<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & V>>>>(s: S) => S

export function set<K2 extends string, S3, A3>(i1: number, k2: K2, l3: Lens<S3, A3>): (v: A3) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K3 extends string>(i1: number, i2: number, k3: K3): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, V>>>>(s: S) => S

export function set(i1: number, i2: number, i3: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<V>>>>(s: S) => S

export function set<T3>(i1: number, i2: number, t3: Traversal<T3>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & V>>>>(s: S) => S

export function set<S3, A3>(i1: number, i2: number, l3: Lens<S3, A3>): (v: A3) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, V>>>>(s: S) => S

export function set<T2>(i1: number, t2: Traversal<T2>, i3: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<V>>>>(s: S) => S

export function set<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & V>>>>(s: S) => S

export function set<T2, S3, A3>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>): (v: A3) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3): (v: KeyAt<A2, K3>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number): (v: Index<A2>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>): (v: Unpack<A2>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>): (v: A3) => <S extends Indexable<S2>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, V>>>>(s: S) => S

export function set<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<V>>>>(s: S) => S

export function set<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & V>>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>): (v: A3) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, V>>>>(s: S) => S

export function set<T1>(t1: Traversal<T1>, i2: number, i3: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<V>>>>(s: S) => S

export function set<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & V>>>>(s: S) => S

export function set<T1, S3, A3>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>): (v: A3) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, V>>>>(s: S) => S

export function set<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<V>>>>(s: S) => S

export function set<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & V>>>>(s: S) => S

export function set<T1, T2, S3, A3>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>): (v: A3) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3): (v: KeyAt<A2, K3>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number): (v: Index<A2>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>): (v: Unpack<A2>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>): (v: A3) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3): (v: KeyAt<KeyAt<A1, K2>, K3>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number): (v: Index<KeyAt<A1, K2>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>): (v: Unpack<KeyAt<A1, K2>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>): (v: A3) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3): (v: KeyAt<Index<A1>, K3>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, i3: number): (v: Index<Index<A1>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>): (v: Unpack<Index<A1>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>): (v: A3) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3): (v: KeyAt<Unpack<A1>, K3>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number): (v: Index<Unpack<A1>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>): (v: Unpack<Unpack<A1>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>): (v: A3) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3): (v: KeyAt<A2, K3>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number): (v: Index<A2>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>): (v: Unpack<A2>) => (s: S1) => S1

export function set<S1, A1, A2, A3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>): (v: A3) => (s: S1) => S1

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string>(k1: K1, k2: K2, k3: K3, k4: K4): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3, i4: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string>(k1: K1, k2: K2, i3: number, k4: K4): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number, i4: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string>(k1: K1, i2: number, k3: K3, k4: K4): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3, i4: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K4 extends string>(k1: K1, i2: number, i3: number, k4: K4): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string>(k1: K1, i2: number, i3: number, i4: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, T4>(k1: K1, i2: number, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, S4, A4>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, T3, T4>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4>, T4>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number, i4: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, T2, T4>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4>, T4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<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): (v: KeyAt<KeyAt<A2, K3>, K4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number): (v: Index<KeyAt<A2, K3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<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>): (v: Unpack<KeyAt<A2, K3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<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>): (v: A4) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4): (v: KeyAt<Index<A2>, K4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number): (v: Index<Index<A2>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>): (v: Unpack<Index<A2>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>): (v: A4) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<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): (v: KeyAt<Unpack<A2>, K4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number): (v: Index<Unpack<A2>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (v: Unpack<Unpack<A2>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (v: A4) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number): (v: Index<A3>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4>, T4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string>(i1: number, k2: K2, k3: K3, k4: K4): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3, i4: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K4 extends string>(i1: number, k2: K2, i3: number, k4: K4): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set<K2 extends string>(i1: number, k2: K2, i3: number, i4: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<V>>>>>(s: S) => S

export function set<K2 extends string, T4>(i1: number, k2: K2, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<K2 extends string, S4, A4>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<K2 extends string, T3, T4>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4>, T4>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K3 extends string, K4 extends string>(i1: number, i2: number, k3: K3, k4: K4): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<K3 extends string>(i1: number, i2: number, k3: K3, i4: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<K3 extends string, T4>(i1: number, i2: number, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<K3 extends string, S4, A4>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K4 extends string>(i1: number, i2: number, i3: number, k4: K4): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set(i1: number, i2: number, i3: number, i4: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<V>>>>>(s: S) => S

export function set<T4>(i1: number, i2: number, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<S4, A4>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<T3, K4 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<T3>(i1: number, i2: number, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<T3, T4>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<T3, S4, A4>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4>, T4>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<T2, K3 extends string, T4>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K4 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set<T2>(i1: number, t2: Traversal<T2>, i3: number, i4: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<V>>>>>(s: S) => S

export function set<T2, T4>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<T2, S4, A4>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, T3, K4 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<T2, T3, T4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<T2, T3, S4, A4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4>, T4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4): (v: KeyAt<KeyAt<A2, K3>, K4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number): (v: Index<KeyAt<A2, K3>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>): (v: Unpack<KeyAt<A2, K3>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>): (v: A4) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4): (v: KeyAt<Index<A2>, K4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number): (v: Index<Index<A2>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4>>, T4>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>): (v: Unpack<Index<A2>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>): (v: A4) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4): (v: KeyAt<Unpack<A2>, K4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number): (v: Index<Unpack<A2>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (v: Unpack<Unpack<A2>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (v: A4) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4>, K4 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number): (v: Index<A3>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4>, T4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends Indexable<S2>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<V>>>>>(s: S) => S

export function set<T1, K2 extends string, T4>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4>, T4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<T1, K3 extends string, T4>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K4 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set<T1>(t1: Traversal<T1>, i2: number, i3: number, i4: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<V>>>>>(s: S) => S

export function set<T1, T4>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<T1, S4, A4>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, T3, K4 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<T1, T3, T4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<T1, T3, S4, A4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4>, K4 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4>, T4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function set<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<V>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, V>>>>>(s: S) => S

export function set<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<V>>>>>(s: S) => S

export function set<T1, T2, T4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & V>>>>>(s: S) => S

export function set<T1, T2, S4, A4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function set<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<V>>>>>(s: S) => S

export function set<T1, T2, T3, T4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>): (v: A4) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number): (v: Index<A3>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4>, T4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4): (v: KeyAt<KeyAt<A2, K3>, K4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number): (v: Index<KeyAt<A2, K3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>): (v: Unpack<KeyAt<A2, K3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>): (v: A4) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4): (v: KeyAt<Index<A2>, K4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number): (v: Index<Index<A2>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>): (v: Unpack<Index<A2>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>): (v: A4) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4): (v: KeyAt<Unpack<A2>, K4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number): (v: Index<Unpack<A2>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (v: Unpack<Unpack<A2>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (v: A4) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4): (v: KeyAt<A3, K4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number): (v: Index<A3>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (v: A4) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4): (v: KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number): (v: Index<KeyAt<KeyAt<A1, K2>, K3>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>): (v: Unpack<KeyAt<KeyAt<A1, K2>, K3>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4): (v: KeyAt<Index<KeyAt<A1, K2>>, K4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number): (v: Index<Index<KeyAt<A1, K2>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>): (v: Unpack<Index<KeyAt<A1, K2>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4): (v: KeyAt<Unpack<KeyAt<A1, K2>>, K4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number): (v: Index<Unpack<KeyAt<A1, K2>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): (v: Unpack<Unpack<KeyAt<A1, K2>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4): (v: KeyAt<A3, K4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number): (v: Index<A3>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4): (v: KeyAt<KeyAt<Index<A1>, K3>, K4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number): (v: Index<KeyAt<Index<A1>, K3>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>): (v: Unpack<KeyAt<Index<A1>, K3>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4): (v: KeyAt<Index<Index<A1>>, K4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number): (v: Index<Index<Index<A1>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>): (v: Unpack<Index<Index<A1>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4): (v: KeyAt<Unpack<Index<A1>>, K4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number): (v: Index<Unpack<Index<A1>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): (v: Unpack<Unpack<Index<A1>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4): (v: KeyAt<A3, K4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number): (v: Index<A3>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4): (v: KeyAt<KeyAt<Unpack<A1>, K3>, K4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number): (v: Index<KeyAt<Unpack<A1>, K3>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): (v: Unpack<KeyAt<Unpack<A1>, K3>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4): (v: KeyAt<Index<Unpack<A1>>, K4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number): (v: Index<Index<Unpack<A1>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): (v: Unpack<Index<Unpack<A1>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): (v: KeyAt<Unpack<Unpack<A1>>, K4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): (v: Index<Unpack<Unpack<A1>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): (v: Unpack<Unpack<Unpack<A1>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4): (v: KeyAt<A3, K4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number): (v: Index<A3>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4): (v: KeyAt<KeyAt<A2, K3>, K4>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number): (v: Index<KeyAt<A2, K3>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>): (v: Unpack<KeyAt<A2, K3>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4): (v: KeyAt<Index<A2>, K4>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number): (v: Index<Index<A2>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>): (v: Unpack<Index<A2>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4): (v: KeyAt<Unpack<A2>, K4>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number): (v: Index<Unpack<A2>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (v: Unpack<Unpack<A2>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (v: A4) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4): (v: KeyAt<A3, K4>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number): (v: Index<A3>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (v: Unpack<A3>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (v: A4) => (s: S1) => S1

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T5>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S5, A5>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, T5>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string>(k1: K1, k2: K2, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, T5>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, S5, A5>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T5>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S5, A5>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, K5 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, T5>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, S5, A5>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Indexable>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4, A5>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, T5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S5, A5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, T5>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, S5, A5>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4, A5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable>>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4, A5>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string>(k1: K1, i2: number, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, T5>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, S5, A5>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T5>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S5, A5>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, K5 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, T5>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, S5, A5>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Indexable>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4, A5>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string>(k1: K1, i2: number, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, T5>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, S5, A5>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K5 extends string>(k1: K1, i2: number, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string>(k1: K1, i2: number, i3: number, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T5>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, S5, A5>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T4, K5 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T4>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T4, T5>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T4, S5, A5>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Indexable>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4, A5>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, T5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, S5, A5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T3, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T3, T5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T3, S5, A5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, T5>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, S5, A5>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4, A5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Indexable>>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable, A5>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Indexable>, T4>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4>, T4, A5>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Collection<T5>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4, A5>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, T5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4, A5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T5>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, S5, A5>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, T5>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, S5, A5>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4, A5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S5, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, S5, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable>, T4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5): (v: KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number): (v: Index<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5): (v: KeyAt<Index<KeyAt<A2, K3>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number): (v: Index<Index<KeyAt<A2, K3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>): (v: Unpack<Index<KeyAt<A2, K3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number): (v: Index<Unpack<KeyAt<A2, K3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<KeyAt<A2, K3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5): (v: KeyAt<KeyAt<Index<A2>, K4>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number): (v: Index<KeyAt<Index<A2>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Index<A2>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5): (v: KeyAt<Index<Index<A2>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable>>>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number): (v: Index<Index<Index<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Index<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable>, A5>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Index<A2>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Index<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Index<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4, A5>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number): (v: Index<KeyAt<Unpack<A2>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Unpack<A2>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5): (v: KeyAt<Index<Unpack<A2>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number): (v: Index<Index<Unpack<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Unpack<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Unpack<A2>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Unpack<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Unpack<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable, A5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable>, T4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Collection<T5>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4, A5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string>(i1: number, k2: K2, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, T5>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, S5, A5>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T5>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S5, A5>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, K5 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, T5>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, S5, A5>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Indexable>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4, A5>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string>(i1: number, k2: K2, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, T5>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, S5, A5>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K5 extends string>(i1: number, k2: K2, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string>(i1: number, k2: K2, i3: number, i4: number, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, T5>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, S5, A5>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, T4, K5 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string, T4>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, T4, T5>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, T4, S5, A5>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Indexable>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Collection<T5>, T5>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4, A5>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, T5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, S5, A5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, T3, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, T3, T5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, T3, S5, A5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, T5>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, S5, A5>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Collection<T5>, T5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4, A5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Indexable>>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable, A5>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4>, T4, A5>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Collection<T5>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4, A5>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K3 extends string, K4 extends string, K5 extends string>(i1: number, i2: number, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string>(i1: number, i2: number, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, T5>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, S5, A5>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K3 extends string, K5 extends string>(i1: number, i2: number, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<K3 extends string>(i1: number, i2: number, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<K3 extends string, T5>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<K3 extends string, S5, A5>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K3 extends string, T4, K5 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<K3 extends string, T4>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<K3 extends string, T4, T5>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<K3 extends string, T4, S5, A5>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Indexable>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Collection<T5>, T5>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4, A5>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K4 extends string, K5 extends string>(i1: number, i2: number, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<K4 extends string>(i1: number, i2: number, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<K4 extends string, T5>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<K4 extends string, S5, A5>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K5 extends string>(i1: number, i2: number, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set(i1: number, i2: number, i3: number, i4: number, i5: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T5>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<S5, A5>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T4, K5 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T4>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T4, T5>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T4, S5, A5>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Indexable>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Collection<T5>, T5>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4, A5>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<T3, K4 extends string, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T3, K4 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T3, K4 extends string, T5>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T3, K4 extends string, S5, A5>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T3, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T3>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T3, T5>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T3, S5, A5>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T3, T4, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T3, T4>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T3, T4, T5>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T3, T4, S5, A5>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T3, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Collection<T5>, T5>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4, A5>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4>, K4 extends string, A5>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Indexable>>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Collection<T5>>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable, A5>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Indexable>, T4>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4>, T4, A5>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Collection<T5>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4, A5>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, S5, A5>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K3 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T2, K3 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, K3 extends string, S5, A5>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, T5>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, S5, A5>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4, A5>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T2, K4 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T2, K4 extends string, T5>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, K4 extends string, S5, A5>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T2>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T2, T5>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, S5, A5>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T2, T4, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T2, T4>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T2, T4, T5>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, T4, S5, A5>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4, A5>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, T3, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, S5, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, T3, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T2, T3, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, T3, S5, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T2, T3, T4, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T2, T3, T4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T2, T3, T4, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T2, T3, T4, S5, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Collection<T5>>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable, A5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Indexable>, T4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4>, T4, A5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4, A5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5): (v: KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number): (v: Index<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5): (v: KeyAt<Index<KeyAt<A2, K3>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number): (v: Index<Index<KeyAt<A2, K3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>): (v: Unpack<Index<KeyAt<A2, K3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number): (v: Index<Unpack<KeyAt<A2, K3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<KeyAt<A2, K3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5): (v: KeyAt<KeyAt<Index<A2>, K4>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number): (v: Index<KeyAt<Index<A2>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Index<A2>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5): (v: KeyAt<Index<Index<A2>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Indexable>>>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number): (v: Index<Index<Index<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Index<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable>, A5>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Index<A2>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Index<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Index<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4>>, T4, A5>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Collection<T5>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4, A5>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number): (v: Index<KeyAt<Unpack<A2>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Unpack<A2>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5): (v: KeyAt<Index<Unpack<A2>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number): (v: Index<Index<Unpack<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Unpack<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable>, T3, A5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Unpack<A2>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Unpack<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Unpack<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4, A5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Collection<T5>>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable, A5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Indexable>, T4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4>, T4, A5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Collection<T5>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4, A5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Indexable<S2>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, S5, A5>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4, A5>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, S5, A5>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4, A5>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S5, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, S5, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable, A5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4, A5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K3 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, K3 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K3 extends string, S5, A5>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, T5>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, S5, A5>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4, A5>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, K4 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, K4 extends string, T5>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, T5>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, S5, A5>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, T4, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T4>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, T4, T5>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T4, S5, A5>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4, A5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T3, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, T3, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T3, S5, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T3, T4, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T3, T4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, T3, T4, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T3, T4, S5, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Collection<T5>>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Indexable>, T4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4>, T4, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2, T4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, T4, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, T3, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, T3, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, T3, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, T3, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function set<T1, T2, T3, T4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Collection<T5>>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable, A5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Indexable>, T4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4>, T4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5): (v: KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number): (v: Index<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5): (v: KeyAt<Index<KeyAt<A2, K3>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number): (v: Index<Index<KeyAt<A2, K3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>): (v: Unpack<Index<KeyAt<A2, K3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number): (v: Index<Unpack<KeyAt<A2, K3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<KeyAt<A2, K3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5): (v: KeyAt<KeyAt<Index<A2>, K4>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number): (v: Index<KeyAt<Index<A2>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Index<A2>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5): (v: KeyAt<Index<Index<A2>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number): (v: Index<Index<Index<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Index<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable>, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Index<A2>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Index<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Index<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number): (v: Index<KeyAt<Unpack<A2>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Unpack<A2>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5): (v: KeyAt<Index<Unpack<A2>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number): (v: Index<Index<Unpack<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Unpack<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Unpack<A2>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Unpack<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Unpack<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Collection<T5>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Indexable>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4>, T4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5): (v: KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable>>>, K2 extends string, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number): (v: Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5>>>>, K2 extends string, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5>>>>, K2 extends string, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5): (v: KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable>>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number): (v: Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5>>>>, K2 extends string, K3 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): (v: Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5>>>>, K2 extends string, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable>>>, K2 extends string, K3 extends string, T4>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): (v: Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5>>>>, K2 extends string, K3 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5>>>>, K2 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5): (v: KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable>>>, K2 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number): (v: Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5>>>>, K2 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5>>>>, K2 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5): (v: KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable>>>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number): (v: Index<Index<Index<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5>>>>, K2 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Index<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5>>>>, K2 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable>>>, K2 extends string, T4>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Index<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5>>>>, K2 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Index<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5>>>>, K2 extends string, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable>>>, K2 extends string, T3, K4 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): (v: Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5>>>>, K2 extends string, T3, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5>>>>, K2 extends string, T3, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): (v: KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable>>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number): (v: Index<Index<Unpack<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>, K2 extends string, T3, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Unpack<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5>>>>, K2 extends string, T3, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable>>>, K2 extends string, T3, T4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Unpack<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5>>>>, K2 extends string, T3, T4, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5>>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5): (v: KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number): (v: Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5>>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5>>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5): (v: KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable>>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number): (v: Index<Index<KeyAt<Index<A1>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5>>>>, K3 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>): (v: Unpack<Index<KeyAt<Index<A1>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5>>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable>>>, K3 extends string, T4>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number): (v: Index<Unpack<KeyAt<Index<A1>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5>>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<KeyAt<Index<A1>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5>>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5): (v: KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable>>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number): (v: Index<KeyAt<Index<Index<A1>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5>>>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Index<Index<A1>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5>>>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5): (v: KeyAt<Index<Index<Index<A1>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Indexable>>>>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number): (v: Index<Index<Index<Index<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5>>>>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Index<Index<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable>>, A5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5>>>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Index<Index<A1>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable>>>, T4>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Index<Index<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5>>>>, T4, T5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Index<Index<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4, A5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5>>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number): (v: Index<KeyAt<Unpack<Index<A1>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5>>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Unpack<Index<A1>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5>>>>, T3, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5): (v: KeyAt<Index<Unpack<Index<A1>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable>>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number): (v: Index<Index<Unpack<Index<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5>>>>, T3, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Unpack<Index<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5>>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Unpack<Index<A1>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable>>>, T3, T4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Unpack<Index<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5>>>>, T3, T4, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Unpack<Index<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5>>>>, T2, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): (v: KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable>>>, T2, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): (v: Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5>>>>, T2, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5>>>>, T2, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): (v: KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable>>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number): (v: Index<Index<KeyAt<Unpack<A1>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5>>>>, T2, K3 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): (v: Unpack<Index<KeyAt<Unpack<A1>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5>>>>, T2, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable>>>, T2, K3 extends string, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): (v: Index<Unpack<KeyAt<Unpack<A1>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5>>>>, T2, K3 extends string, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5>>>>, T2, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): (v: KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable>>>, T2, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number): (v: Index<KeyAt<Index<Unpack<A1>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5>>>>, T2, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Index<Unpack<A1>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5>>>>, T2, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5): (v: KeyAt<Index<Index<Unpack<A1>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable>>>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number): (v: Index<Index<Index<Unpack<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5>>>>, T2, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Index<Unpack<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5>>>>, T2, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Index<Unpack<A1>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable>>>, T2, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Index<Unpack<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5>>>>, T2, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Index<Unpack<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5>>>>, T2, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable>>>, T2, T3, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): (v: Index<KeyAt<Unpack<Unpack<A1>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5>>>>, T2, T3, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5>>>>, T2, T3, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): (v: KeyAt<Index<Unpack<Unpack<A1>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable>>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): (v: Index<Index<Unpack<Unpack<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5>>>>, T2, T3, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Unpack<Unpack<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5>>>>, T2, T3, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable>>>, T2, T3, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Unpack<Unpack<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5>>>>, T2, T3, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Unpack<Unpack<A1>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5): (v: KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number): (v: Index<KeyAt<KeyAt<A2, K3>, K4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5): (v: KeyAt<Index<KeyAt<A2, K3>>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number): (v: Index<Index<KeyAt<A2, K3>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>): (v: Unpack<Index<KeyAt<A2, K3>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number): (v: Index<Unpack<KeyAt<A2, K3>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<KeyAt<A2, K3>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5): (v: KeyAt<KeyAt<Index<A2>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number): (v: Index<KeyAt<Index<A2>, K4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Index<A2>, K4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5): (v: KeyAt<Index<Index<A2>>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number): (v: Index<Index<Index<A2>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Index<A2>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable>, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Index<A2>>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Index<A2>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Index<A2>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number): (v: Index<KeyAt<Unpack<A2>, K4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<Unpack<A2>, K4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5): (v: KeyAt<Index<Unpack<A2>>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number): (v: Index<Index<Unpack<A2>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<Unpack<A2>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<Unpack<A2>>, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<Unpack<A2>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<Unpack<A2>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (v: KeyAt<KeyAt<A3, K4>, K5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (v: Index<KeyAt<A3, K4>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (v: Unpack<KeyAt<A3, K4>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (v: KeyAt<Index<A3>, K5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (v: Index<Index<A3>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (v: Unpack<Index<A3>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (v: KeyAt<Unpack<A3>, K5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (v: Index<Unpack<A3>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (v: Unpack<Unpack<A3>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (v: A5) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (v: KeyAt<A4, K5>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (v: Index<A4>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (v: Unpack<A4>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (v: A5) => (s: S1) => S1

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T6>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, T6>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T6>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T5>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T5, T6>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T5, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S5, A5, A6>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, T5>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, T5, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, T5, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, T6>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, T5>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, T5, T6>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K5 extends string, T6>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T6>(k1: K1, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T5, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T5>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T5, T6>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T5, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S5, A5, A6>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, K5 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, K5 extends string, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, T5, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, T5>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, T5, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, T5, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T4, S5, A5, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S4, A4, A5, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, T5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, T5>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, T4, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, T3, S4, A4, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K2 extends string, S3, A3, A4, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, T6>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, T5>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, T5, T6>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, T5, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K5 extends string, T6>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T6>(k1: K1, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T5, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T5>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T5, T6>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T5, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S5, A5, A6>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, K5 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, K5 extends string, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, T5, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, T5>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, T5, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, T5, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, T4, S5, A5, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K3 extends string, S4, A4, A5, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string>(k1: K1, i2: number, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, T6>(k1: K1, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, T5>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, T5, T6>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, T5, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K4 extends string, S5, A5, A6>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, K5 extends string>(k1: K1, i2: number, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, K5 extends string, T6>(k1: K1, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string>(k1: K1, i2: number, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T6>(k1: K1, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, S6, A6>(k1: K1, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T5, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T5>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T5, T6>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T5, S6, A6>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, S5, A5, A6>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T4, K5 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T4, K5 extends string, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T4, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T4, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T4>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T4, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T4, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T4, T5, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T4, T5>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T4, T5, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T4, T5, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T4, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T4, S5, A5, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Indexable, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4, A5 extends Indexable>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, S4, A4, A5, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, T5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T3, K4 extends string, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T3, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T3, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T3, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, T5>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T3, T4, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Indexable, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T3, S4, A4, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Indexable, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Indexable, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, S3, A3, A4, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, T5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K3 extends string, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T5>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, T5>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, T3, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Indexable, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, T2, S3, A3, A4, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): (v: Index<Index<Index<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Index<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Index<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Index<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Index<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Index<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): (v: Index<Index<Index<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable>>, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Index<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Indexable>, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Index<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Indexable, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Unpack<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Indexable>, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Indexable, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K1 extends string, S2, A2, A3, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, T6>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, T5>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, T5, T6>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K5 extends string, T6>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T6>(i1: number, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T5, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T5>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T5, T6>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T5, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S5, A5, A6>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, K5 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, K5 extends string, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, T5, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, T5>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, T5, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, T5, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, T4, S5, A5, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K3 extends string, S4, A4, A5, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string>(i1: number, k2: K2, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, T6>(i1: number, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, T5>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, T5, T6>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, T5, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K4 extends string, S5, A5, A6>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, K5 extends string>(i1: number, k2: K2, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, K5 extends string, T6>(i1: number, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string>(i1: number, k2: K2, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T6>(i1: number, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, S6, A6>(i1: number, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, T5, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T5>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T5, T6>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T5, S6, A6>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, S5, A5, A6>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T4, K5 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T4, K5 extends string, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T4, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, T4, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T4>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T4, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T4, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, T4, T5, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T4, T5>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T4, T5, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T4, T5, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, T4, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, T4, S5, A5, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Indexable, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4, A5 extends Indexable>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, S4, A4, A5, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, T5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, T3, K4 extends string, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<K2 extends string, T3, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, T3, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, T3, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, T5>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, T3, T4, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Indexable, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, T3, S4, A4, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Indexable, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Indexable, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K2 extends string, S3, A3, A4, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function set<K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, K5 extends string>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string>(i1: number, i2: number, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, T6>(i1: number, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, T5>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, T5, T6>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, T5, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K3 extends string, K4 extends string, S5, A5, A6>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<K3 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string, K5 extends string>(i1: number, i2: number, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, K5 extends string, T6>(i1: number, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K3 extends string, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string>(i1: number, i2: number, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, T6>(i1: number, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, S6, A6>(i1: number, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<K3 extends string, T5, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string, T5>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, T5, T6>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, T5, S6, A6>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K3 extends string, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K3 extends string, S5, A5, A6>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string, T4, K5 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, T4, K5 extends string, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, T4, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<K3 extends string, T4, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string, T4>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, T4, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, T4, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<K3 extends string, T4, T5, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K3 extends string, T4, T5>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K3 extends string, T4, T5, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K3 extends string, T4, T5, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K3 extends string, T4, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K3 extends string, T4, S5, A5, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Indexable, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4, A5 extends Indexable>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K3 extends string, S4, A4, A5, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K4 extends string, K5 extends string>(i1: number, i2: number, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K4 extends string, K5 extends string, T6>(i1: number, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<K4 extends string, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<K4 extends string>(i1: number, i2: number, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<K4 extends string, T6>(i1: number, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<K4 extends string, S6, A6>(i1: number, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<K4 extends string, T5, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<K4 extends string, T5>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<K4 extends string, T5, T6>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<K4 extends string, T5, S6, A6>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K4 extends string, S5, A5, A6>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<K5 extends string>(i1: number, i2: number, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<K5 extends string, T6>(i1: number, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<K5 extends string, S6, A6>(i1: number, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<K6 extends string>(i1: number, i2: number, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set(i1: number, i2: number, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T6>(i1: number, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<S6, A6>(i1: number, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T5, K6 extends string>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T5>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T5, T6>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T5, S6, A6>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<S5, A5 extends Indexable>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<S5, A5, A6>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T4, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T4, K5 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T4, K5 extends string, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T4, K5 extends string, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T4, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T4>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T4, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T4, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T4, T5, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T4, T5>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T4, T5, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T4, T5, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T4, S5, A5 extends Indexable>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T4, S5, A5, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Indexable, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4, A5 extends Indexable>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<S4, A4, A5, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function set<T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3, K4 extends string, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T3, K4 extends string, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T3, K4 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3, K4 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T3, K4 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, K4 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T3, K4 extends string, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3, K4 extends string, T5>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T3, K4 extends string, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, K4 extends string, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T3, K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T3, K4 extends string, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T3, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T3, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T3, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T3, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T3, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3, T5>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T3, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T3, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T3, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T3, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T3, T4, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3, T4, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T3, T4, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, T4, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T3, T4, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3, T4>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T3, T4, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, T4, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T3, T4, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T3, T4, T5>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T3, T4, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T3, T4, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T3, T4, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T3, T4, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Indexable, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T3, S4, A4, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Indexable>, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Indexable, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Indexable<Indexable>>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Indexable, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<S3, A3, A4, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K3 extends string, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K3 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T2, K3 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T2, K3 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, T5>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, K3 extends string, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K3 extends string, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T2, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K4 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, K4 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T2, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K4 extends string, T5>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T2, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T5>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T2, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T2, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T2, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T2, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T4, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, T4, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T4>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, T4, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T4, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T2, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T4, T5>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, T4, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T2, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, T3, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T2, T3, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, T3, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T2, T3, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T2, T3, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T2, T3, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T2, T3, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T2, T3, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3, T4, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T2, T3, T4, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3, T4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, T4, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, T4, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T2, T3, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T2, T3, T4, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T2, T3, T4, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T2, T3, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, T3, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, T3, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, T3, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Indexable>, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Indexable, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<T2, S3, A3, A4, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): (v: Index<Index<Index<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Index<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Index<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Index<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Index<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Index<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): (v: Index<Index<Index<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Indexable>>, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Index<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Indexable>, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Index<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Indexable, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Unpack<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2 extends Collection<T3>, T3, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Indexable<Indexable>>>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Indexable>, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Indexable, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3 extends Collection<T4>, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function set<S2, A2, A3, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Indexable<S2>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, T3, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K2 extends string, S3, A3, A4, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, T5>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function set<T1, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K4 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, K4 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K4 extends string, T5>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T5>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T4, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T4, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T4>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T4, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T4, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T4, T5>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T4, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function set<T1, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T3, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, T3, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T3, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3, T4, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T3, T4, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3, T4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, T4, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, T4, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T3, T4, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T3, T4, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T3, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T3, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T3, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, S3, A3, A4, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function set<T1, T2, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function set<T1, T2, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, T3, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, T3, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, T3, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function set<T1, T2, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(v: V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function set<T1, T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, T3, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, T3, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, T2, S3, A3, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): (v: Index<Index<Index<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Index<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Index<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Index<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Index<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Index<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): (v: Index<Index<Index<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Indexable>>, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Index<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Indexable>, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Index<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Indexable, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Unpack<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2 extends Collection<T3>, T3, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<T1, S2, A2, A3, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, K2 extends string, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable>>>, K2 extends string, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5>>>>, K2 extends string, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5>>>>, K2 extends string, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable>>>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, i6: number): (v: Index<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable>>>, K2 extends string, K3 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5>>>>, K2 extends string, K3 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5>>>>, K2 extends string, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, K2 extends string, K3 extends string, T4>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, T4, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable>>>, K2 extends string, K3 extends string, T4, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5>>>>, K2 extends string, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5>>>>, K2 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable>>>>, K2 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable>>>, K2 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5>>>>, K2 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable>>>>, K2 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5>>>>, K2 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Index<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<Indexable>>>>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, i6: number): (v: Index<Index<Index<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<Collection<T6>>>>>, K2 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable>>>, K2 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<KeyAt<A1, K2>>>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Index<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable>>>>, K2 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5>>>>, K2 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5>>>>, K2 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Index<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable>>>>, K2 extends string, T4>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, T4, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable>>>, K2 extends string, T4, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Index<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5>>>>, K2 extends string, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5>>>>, K2 extends string, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, K2 extends string, T3, K4 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, T3, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable>>>, K2 extends string, T3, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, T3, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5>>>>, K2 extends string, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, K2 extends string, T3, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5>>>>, K2 extends string, T3, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, T3, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Unpack<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable>>>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, K2 extends string, T3, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable>>>, K2 extends string, T3, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Unpack<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, K2 extends string, T3, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>, K2 extends string, T3, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, T3, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5>>>>, K2 extends string, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, T3, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Unpack<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, K2 extends string, T3, T4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, T3, T4, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable>>>, K2 extends string, T3, T4, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, T3, T4, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5>>>>, K2 extends string, T3, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5>>>>, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable>>>, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5>>>>, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5>>>>, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<KeyAt<Index<A1>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<Indexable>>>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, i6: number): (v: Index<Index<Index<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, K3 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable>>>, K3 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<Index<A1>, K3>>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<KeyAt<Index<A1>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, K3 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, K3 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5>>>>, K3 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5>>>>, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<KeyAt<Index<A1>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, K3 extends string, T4>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, K3 extends string, T4, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable>>>, K3 extends string, T4, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<KeyAt<Index<A1>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5>>>>, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5>>>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Index<Index<A1>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<Indexable>>>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Index<Index<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Index<Index<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable>>>, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<Index<A1>>, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Index<Index<A1>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Index<Index<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Index<Index<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5>>>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Index<Index<A1>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, Indexable>>>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Index<Index<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Index<Index<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5>>>>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<Index<A1>>>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Indexable<HasKey<K6>>>>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Index<Index<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Indexable<Indexable>>>>>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, i6: number): (v: Index<Index<Index<Index<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Indexable<Collection<T6>>>>>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Index<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Indexable>>>, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<Index<A1>>>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Index<Index<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & Indexable>>>>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Index<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Index<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5>>>>, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Indexable>>, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Index<Index<A1>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Index<Index<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Index<Index<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5>>>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Index<Index<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<Indexable>>>>, T4>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Index<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, T4, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Index<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable>>>, T4, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Index<Index<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, T4, T5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Index<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Index<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5>>>>, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Indexable>, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5>>>>, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Unpack<Index<A1>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Unpack<Index<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, T3, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Unpack<Index<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable>>>, T3, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Unpack<Index<A1>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Unpack<Index<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Unpack<Index<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5>>>>, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Unpack<Index<A1>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, T3, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Unpack<Index<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, T3, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Unpack<Index<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5>>>>, T3, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, T3, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Unpack<Index<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<Indexable>>>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, T3, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable>>>, T3, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, T3, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Unpack<Index<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, T3, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, T3, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5>>>>, T3, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Unpack<Index<A1>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Unpack<Index<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Unpack<Index<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5>>>>, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, T3, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Unpack<Index<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, T3, T4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, T3, T4, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable>>>, T3, T4, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Unpack<Index<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, T3, T4, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, T3, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5>>>>, T3, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Indexable, A3, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, T2, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5>>>>, T2, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<T2, K3>, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, T2, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, T2, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable>>>, T2, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<T2, K3>, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, T2, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5>>>>, T2, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, T2, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5>>>>, T2, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<T2, K3>>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, T2, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<KeyAt<Unpack<A1>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable>>>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): (v: Index<Index<Index<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, T2, K3 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable>>>, T2, K3 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<T2, K3>>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<KeyAt<Unpack<A1>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, T2, K3 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5>>>>, T2, K3 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, T2, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5>>>>, T2, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, T2, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<KeyAt<Unpack<A1>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, T2, K3 extends string, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, T2, K3 extends string, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable>>>, T2, K3 extends string, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, T2, K3 extends string, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5>>>>, T2, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, T2, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5>>>>, T2, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<T2>, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, T2, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Index<Unpack<A1>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable>>>>, T2, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Index<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, T2, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Index<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable>>>, T2, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<T2>, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Index<Unpack<A1>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, T2, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Index<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Index<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5>>>>, T2, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, T2, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Index<Unpack<A1>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable>>>>, T2, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Index<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, T2, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Index<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5>>>>, T2, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<T2>>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6>>>>>, T2, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Index<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<Indexable>>>>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): (v: Index<Index<Index<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<Collection<T6>>>>>, T2, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable>>>, T2, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<T2>>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, T2, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Index<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable>>>>, T2, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, T2, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5>>>>, T2, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Index<Unpack<A1>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, T2, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Index<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Index<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5>>>>, T2, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, T2, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Index<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable>>>>, T2, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, T2, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable>>>, T2, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Index<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, T2, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5>>>>, T2, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, T2, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5>>>>, T2, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, T2, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Unpack<Unpack<A1>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, T2, T3, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Unpack<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, T2, T3, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Unpack<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable>>>, T2, T3, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, T2, T3, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5>>>>, T2, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, T2, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Unpack<Unpack<A1>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, T2, T3, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Unpack<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, T2, T3, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Unpack<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5>>>>, T2, T3, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, T2, T3, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Unpack<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable>>>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, T2, T3, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable>>>, T2, T3, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, T2, T3, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Unpack<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, T2, T3, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, T2, T3, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5>>>>, T2, T3, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, T2, T3, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5>>>>, T2, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, T2, T3, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Unpack<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, T2, T3, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, T2, T3, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable>>>, T2, T3, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Unpack<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, T2, T3, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, T3, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5>>>>, T2, T3, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1 extends Collection<T2>, T2, A3, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, i6: number): (v: Index<Index<Index<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Index<A2>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Index<A2>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Index<A2>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Index<A2>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Index<A2>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Index<A2>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, i6: number): (v: Index<Index<Index<Index<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Index<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Indexable>>, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Index<A2>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Index<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Index<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable>, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Indexable>, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Index<A2>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Index<A2>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Index<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Index<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Index<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Index<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Indexable, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<Unpack<A2>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<Unpack<A2>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<Unpack<A2>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<Unpack<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<Unpack<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<Unpack<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<Unpack<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<Unpack<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<Unpack<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<Unpack<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<Unpack<A2>>>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2 extends Collection<T3>, T3, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (v: Index<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (v: Unpack<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (v: Index<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (v: Index<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (v: KeyAt<Index<Index<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (v: Index<Index<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Index<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Index<A3>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (v: Index<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (v: KeyAt<Index<Unpack<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (v: Index<Index<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<Unpack<A3>>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (v: KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (v: Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (v: Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (v: KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (v: Index<Index<A4>>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (v: Unpack<Index<A4>>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (v: KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (v: Index<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (v: Unpack<Unpack<A4>>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (v: A6) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (v: KeyAt<A5, K6>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (v: Index<A5>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (v: Unpack<A5>) => (s: S1) => S1

export function set<S1, A1, A2, A3, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (v: A6) => (s: S1) => S1


export function mod<K1 extends string>(k1: K1): <V>(f: (v: V) => V) => <S extends HasKey<K1, V>>(s: S) => S

export function mod(i1: number): <V>(f: (v: V) => V) => <S extends Indexable<V>>(s: S) => S

export function mod<T1>(t1: Traversal<T1>): <V>(f: (v: V) => V) => <S extends Collection<T1 & V>>(s: S) => S

export function mod<S1, A1>(l1: Lens<S1, A1>): (f: (v: A1) => A1) => (s: S1) => S1

export function mod<K1 extends string, K2 extends string>(k1: K1, k2: K2): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, V>>>(s: S) => S

export function mod<K1 extends string>(k1: K1, i2: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<V>>>(s: S) => S

export function mod<K1 extends string, T2>(k1: K1, t2: Traversal<T2>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & V>>>(s: S) => S

export function mod<K1 extends string, S2, A2>(k1: K1, l2: Lens<S2, A2>): (f: (v: A2) => A2) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K2 extends string>(i1: number, k2: K2): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, V>>>(s: S) => S

export function mod(i1: number, i2: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<V>>>(s: S) => S

export function mod<T2>(i1: number, t2: Traversal<T2>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & V>>>(s: S) => S

export function mod<S2, A2>(i1: number, l2: Lens<S2, A2>): (f: (v: A2) => A2) => <S extends Indexable<S2>>(s: S) => S

export function mod<T1, K2 extends string>(t1: Traversal<T1>, k2: K2): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, V>>>(s: S) => S

export function mod<T1>(t1: Traversal<T1>, i2: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<V>>>(s: S) => S

export function mod<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & V>>>(s: S) => S

export function mod<T1, S2, A2>(t1: Traversal<T1>, l2: Lens<S2, A2>): (f: (v: A2) => A2) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<S1, A1 extends HasKey<K2>, K2 extends string>(l1: Lens<S1, A1>, k2: K2): (f: (v: KeyAt<A1, K2>) => KeyAt<A1, K2>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable>(l1: Lens<S1, A1>, i2: number): (f: (v: Index<A1>) => Index<A1>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>): (f: (v: Unpack<A1>) => Unpack<A1>) => (s: S1) => S1

export function mod<S1, A1, A2>(l1: Lens<S1, A1>, l2: Lens<A1, A2>): (f: (v: A2) => A2) => (s: S1) => S1

export function mod<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, V>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<V>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & V>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3>(k1: K1, k2: K2, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, V>>>>(s: S) => S

export function mod<K1 extends string>(k1: K1, i2: number, i3: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<V>>>>(s: S) => S

export function mod<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & V>>>>(s: S) => S

export function mod<K1 extends string, S3, A3>(k1: K1, i2: number, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, V>>>>(s: S) => S

export function mod<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<V>>>>(s: S) => S

export function mod<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & V>>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3): (f: (v: KeyAt<A2, K3>) => KeyAt<A2, K3>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number): (f: (v: Index<A2>) => Index<A2>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>): (f: (v: Unpack<A2>) => Unpack<A2>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>): (f: (v: A3) => A3) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, V>>>>(s: S) => S

export function mod<K2 extends string>(i1: number, k2: K2, i3: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<V>>>>(s: S) => S

export function mod<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & V>>>>(s: S) => S

export function mod<K2 extends string, S3, A3>(i1: number, k2: K2, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K3 extends string>(i1: number, i2: number, k3: K3): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, V>>>>(s: S) => S

export function mod(i1: number, i2: number, i3: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<V>>>>(s: S) => S

export function mod<T3>(i1: number, i2: number, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & V>>>>(s: S) => S

export function mod<S3, A3>(i1: number, i2: number, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, V>>>>(s: S) => S

export function mod<T2>(i1: number, t2: Traversal<T2>, i3: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<V>>>>(s: S) => S

export function mod<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & V>>>>(s: S) => S

export function mod<T2, S3, A3>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3): (f: (v: KeyAt<A2, K3>) => KeyAt<A2, K3>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number): (f: (v: Index<A2>) => Index<A2>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>): (f: (v: Unpack<A2>) => Unpack<A2>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>): (f: (v: A3) => A3) => <S extends Indexable<S2>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, V>>>>(s: S) => S

export function mod<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<V>>>>(s: S) => S

export function mod<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & V>>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, V>>>>(s: S) => S

export function mod<T1>(t1: Traversal<T1>, i2: number, i3: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<V>>>>(s: S) => S

export function mod<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & V>>>>(s: S) => S

export function mod<T1, S3, A3>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, V>>>>(s: S) => S

export function mod<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<V>>>>(s: S) => S

export function mod<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & V>>>>(s: S) => S

export function mod<T1, T2, S3, A3>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>): (f: (v: A3) => A3) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3): (f: (v: KeyAt<A2, K3>) => KeyAt<A2, K3>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number): (f: (v: Index<A2>) => Index<A2>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>): (f: (v: Unpack<A2>) => Unpack<A2>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>): (f: (v: A3) => A3) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3): (f: (v: KeyAt<KeyAt<A1, K2>, K3>) => KeyAt<KeyAt<A1, K2>, K3>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number): (f: (v: Index<KeyAt<A1, K2>>) => Index<KeyAt<A1, K2>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>): (f: (v: Unpack<KeyAt<A1, K2>>) => Unpack<KeyAt<A1, K2>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>): (f: (v: A3) => A3) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3): (f: (v: KeyAt<Index<A1>, K3>) => KeyAt<Index<A1>, K3>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, i3: number): (f: (v: Index<Index<A1>>) => Index<Index<A1>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>): (f: (v: Unpack<Index<A1>>) => Unpack<Index<A1>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>): (f: (v: A3) => A3) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3): (f: (v: KeyAt<Unpack<A1>, K3>) => KeyAt<Unpack<A1>, K3>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number): (f: (v: Index<Unpack<A1>>) => Index<Unpack<A1>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>): (f: (v: Unpack<Unpack<A1>>) => Unpack<Unpack<A1>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>): (f: (v: A3) => A3) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3): (f: (v: KeyAt<A2, K3>) => KeyAt<A2, K3>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number): (f: (v: Index<A2>) => Index<A2>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>): (f: (v: Unpack<A2>) => Unpack<A2>) => (s: S1) => S1

export function mod<S1, A1, A2, A3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>): (f: (v: A3) => A3) => (s: S1) => S1

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string>(k1: K1, k2: K2, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string>(k1: K1, k2: K2, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string>(k1: K1, i2: number, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string>(k1: K1, i2: number, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string>(k1: K1, i2: number, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, T4>(k1: K1, i2: number, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, S4, A4>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4>, T4>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4>, T4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<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): (f: (v: KeyAt<KeyAt<A2, K3>, K4>) => KeyAt<KeyAt<A2, K3>, K4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number): (f: (v: Index<KeyAt<A2, K3>>) => Index<KeyAt<A2, K3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<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>): (f: (v: Unpack<KeyAt<A2, K3>>) => Unpack<KeyAt<A2, K3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<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>): (f: (v: A4) => A4) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4): (f: (v: KeyAt<Index<A2>, K4>) => KeyAt<Index<A2>, K4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number): (f: (v: Index<Index<A2>>) => Index<Index<A2>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>): (f: (v: Unpack<Index<A2>>) => Unpack<Index<A2>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<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): (f: (v: KeyAt<Unpack<A2>, K4>) => KeyAt<Unpack<A2>, K4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number): (f: (v: Index<Unpack<A2>>) => Index<Unpack<A2>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (f: (v: Unpack<Unpack<A2>>) => Unpack<Unpack<A2>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4>, T4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string>(i1: number, k2: K2, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string>(i1: number, k2: K2, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod<K2 extends string>(i1: number, k2: K2, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<V>>>>>(s: S) => S

export function mod<K2 extends string, T4>(i1: number, k2: K2, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<K2 extends string, S4, A4>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4>, T4>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K3 extends string, K4 extends string>(i1: number, i2: number, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<K3 extends string>(i1: number, i2: number, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<K3 extends string, T4>(i1: number, i2: number, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<K3 extends string, S4, A4>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K4 extends string>(i1: number, i2: number, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod(i1: number, i2: number, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<V>>>>>(s: S) => S

export function mod<T4>(i1: number, i2: number, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<S4, A4>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T3, K4 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<T3>(i1: number, i2: number, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<T3, T4>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<T3, S4, A4>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4>, T4>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K4 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod<T2>(i1: number, t2: Traversal<T2>, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<V>>>>>(s: S) => S

export function mod<T2, T4>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<T2, S4, A4>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, T3, K4 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<T2, T3, T4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<T2, T3, S4, A4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4>, K4 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4>, T4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4): (f: (v: KeyAt<KeyAt<A2, K3>, K4>) => KeyAt<KeyAt<A2, K3>, K4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number): (f: (v: Index<KeyAt<A2, K3>>) => Index<KeyAt<A2, K3>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>): (f: (v: Unpack<KeyAt<A2, K3>>) => Unpack<KeyAt<A2, K3>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>): (f: (v: A4) => A4) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4): (f: (v: KeyAt<Index<A2>, K4>) => KeyAt<Index<A2>, K4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number): (f: (v: Index<Index<A2>>) => Index<Index<A2>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4>>, T4>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>): (f: (v: Unpack<Index<A2>>) => Unpack<Index<A2>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>): (f: (v: A4) => A4) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4): (f: (v: KeyAt<Unpack<A2>, K4>) => KeyAt<Unpack<A2>, K4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number): (f: (v: Index<Unpack<A2>>) => Index<Unpack<A2>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (f: (v: Unpack<Unpack<A2>>) => Unpack<Unpack<A2>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (f: (v: A4) => A4) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4>, K4 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4>, T4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends Indexable<S2>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<V>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4>, T4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K4 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod<T1>(t1: Traversal<T1>, i2: number, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<V>>>>>(s: S) => S

export function mod<T1, T4>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, S4, A4>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, T3, K4 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<T1, T3, T4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, T3, S4, A4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4>, K4 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4>, T4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, V>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<V>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, V>>>>>(s: S) => S

export function mod<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<V>>>>>(s: S) => S

export function mod<T1, T2, T4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, T2, S4, A4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, V>>>>>(s: S) => S

export function mod<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<V>>>>>(s: S) => S

export function mod<T1, T2, T3, T4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & V>>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4>, T4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4): (f: (v: KeyAt<KeyAt<A2, K3>, K4>) => KeyAt<KeyAt<A2, K3>, K4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number): (f: (v: Index<KeyAt<A2, K3>>) => Index<KeyAt<A2, K3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>): (f: (v: Unpack<KeyAt<A2, K3>>) => Unpack<KeyAt<A2, K3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4): (f: (v: KeyAt<Index<A2>, K4>) => KeyAt<Index<A2>, K4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number): (f: (v: Index<Index<A2>>) => Index<Index<A2>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>): (f: (v: Unpack<Index<A2>>) => Unpack<Index<A2>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4): (f: (v: KeyAt<Unpack<A2>, K4>) => KeyAt<Unpack<A2>, K4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number): (f: (v: Index<Unpack<A2>>) => Index<Unpack<A2>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (f: (v: Unpack<Unpack<A2>>) => Unpack<Unpack<A2>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4): (f: (v: KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>) => KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number): (f: (v: Index<KeyAt<KeyAt<A1, K2>, K3>>) => Index<KeyAt<KeyAt<A1, K2>, K3>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>): (f: (v: Unpack<KeyAt<KeyAt<A1, K2>, K3>>) => Unpack<KeyAt<KeyAt<A1, K2>, K3>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4): (f: (v: KeyAt<Index<KeyAt<A1, K2>>, K4>) => KeyAt<Index<KeyAt<A1, K2>>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number): (f: (v: Index<Index<KeyAt<A1, K2>>>) => Index<Index<KeyAt<A1, K2>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>): (f: (v: Unpack<Index<KeyAt<A1, K2>>>) => Unpack<Index<KeyAt<A1, K2>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4): (f: (v: KeyAt<Unpack<KeyAt<A1, K2>>, K4>) => KeyAt<Unpack<KeyAt<A1, K2>>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number): (f: (v: Index<Unpack<KeyAt<A1, K2>>>) => Index<Unpack<KeyAt<A1, K2>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>): (f: (v: Unpack<Unpack<KeyAt<A1, K2>>>) => Unpack<Unpack<KeyAt<A1, K2>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4): (f: (v: KeyAt<KeyAt<Index<A1>, K3>, K4>) => KeyAt<KeyAt<Index<A1>, K3>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number): (f: (v: Index<KeyAt<Index<A1>, K3>>) => Index<KeyAt<Index<A1>, K3>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>): (f: (v: Unpack<KeyAt<Index<A1>, K3>>) => Unpack<KeyAt<Index<A1>, K3>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4): (f: (v: KeyAt<Index<Index<A1>>, K4>) => KeyAt<Index<Index<A1>>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number): (f: (v: Index<Index<Index<A1>>>) => Index<Index<Index<A1>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>): (f: (v: Unpack<Index<Index<A1>>>) => Unpack<Index<Index<A1>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4): (f: (v: KeyAt<Unpack<Index<A1>>, K4>) => KeyAt<Unpack<Index<A1>>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number): (f: (v: Index<Unpack<Index<A1>>>) => Index<Unpack<Index<A1>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>): (f: (v: Unpack<Unpack<Index<A1>>>) => Unpack<Unpack<Index<A1>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4): (f: (v: KeyAt<KeyAt<Unpack<A1>, K3>, K4>) => KeyAt<KeyAt<Unpack<A1>, K3>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number): (f: (v: Index<KeyAt<Unpack<A1>, K3>>) => Index<KeyAt<Unpack<A1>, K3>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>): (f: (v: Unpack<KeyAt<Unpack<A1>, K3>>) => Unpack<KeyAt<Unpack<A1>, K3>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4): (f: (v: KeyAt<Index<Unpack<A1>>, K4>) => KeyAt<Index<Unpack<A1>>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number): (f: (v: Index<Index<Unpack<A1>>>) => Index<Index<Unpack<A1>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>): (f: (v: Unpack<Index<Unpack<A1>>>) => Unpack<Index<Unpack<A1>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4): (f: (v: KeyAt<Unpack<Unpack<A1>>, K4>) => KeyAt<Unpack<Unpack<A1>>, K4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number): (f: (v: Index<Unpack<Unpack<A1>>>) => Index<Unpack<Unpack<A1>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>): (f: (v: Unpack<Unpack<Unpack<A1>>>) => Unpack<Unpack<Unpack<A1>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4): (f: (v: KeyAt<KeyAt<A2, K3>, K4>) => KeyAt<KeyAt<A2, K3>, K4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number): (f: (v: Index<KeyAt<A2, K3>>) => Index<KeyAt<A2, K3>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>): (f: (v: Unpack<KeyAt<A2, K3>>) => Unpack<KeyAt<A2, K3>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4): (f: (v: KeyAt<Index<A2>, K4>) => KeyAt<Index<A2>, K4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number): (f: (v: Index<Index<A2>>) => Index<Index<A2>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>): (f: (v: Unpack<Index<A2>>) => Unpack<Index<A2>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4): (f: (v: KeyAt<Unpack<A2>, K4>) => KeyAt<Unpack<A2>, K4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number): (f: (v: Index<Unpack<A2>>) => Index<Unpack<A2>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>): (f: (v: Unpack<Unpack<A2>>) => Unpack<Unpack<A2>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4): (f: (v: KeyAt<A3, K4>) => KeyAt<A3, K4>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number): (f: (v: Index<A3>) => Index<A3>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>): (f: (v: Unpack<A3>) => Unpack<A3>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>): (f: (v: A4) => A4) => (s: S1) => S1

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T5>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S5, A5>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, T5>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string>(k1: K1, k2: K2, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, T5>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, S5, A5>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T5>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S5, A5>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, K5 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, T5>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, S5, A5>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Indexable>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4, A5>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, T5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S5, A5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, T5>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, S5, A5>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4, A5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable>>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4, A5>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string>(k1: K1, i2: number, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, T5>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, S5, A5>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T5>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S5, A5>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, K5 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, T5>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, S5, A5>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Indexable>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4, A5>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string>(k1: K1, i2: number, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, T5>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, S5, A5>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K5 extends string>(k1: K1, i2: number, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string>(k1: K1, i2: number, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T5>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, S5, A5>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T4, K5 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T4>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T4, T5>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T4, S5, A5>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Indexable>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4, A5>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, T5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, S5, A5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T3, S5, A5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, T5>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, S5, A5>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4, A5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Indexable>>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable, A5>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Indexable>, T4>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4>, T4, A5>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Collection<T5>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4, A5>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, T5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, S5, A5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4, A5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T5>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, S5, A5>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, T5>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, S5, A5>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4, A5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, S5, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S5, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, S5, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4, A5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable>, T4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Collection<T5>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4, A5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number): (f: (v: Index<KeyAt<KeyAt<A2, K3>, K4>>) => Index<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5): (f: (v: KeyAt<Index<KeyAt<A2, K3>>, K5>) => KeyAt<Index<KeyAt<A2, K3>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number): (f: (v: Index<Index<KeyAt<A2, K3>>>) => Index<Index<KeyAt<A2, K3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<KeyAt<A2, K3>>>) => Unpack<Index<KeyAt<A2, K3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<KeyAt<A2, K3>>>) => Index<Unpack<KeyAt<A2, K3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<KeyAt<A2, K3>>>) => Unpack<Unpack<KeyAt<A2, K3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Index<A2>, K4>, K5>) => KeyAt<KeyAt<Index<A2>, K4>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number): (f: (v: Index<KeyAt<Index<A2>, K4>>) => Index<KeyAt<Index<A2>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Index<A2>, K4>>) => Unpack<KeyAt<Index<A2>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5): (f: (v: KeyAt<Index<Index<A2>>, K5>) => KeyAt<Index<Index<A2>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable>>>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number): (f: (v: Index<Index<Index<A2>>>) => Index<Index<Index<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Index<A2>>>) => Unpack<Index<Index<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable>, A5>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Index<A2>>, K5>) => KeyAt<Unpack<Index<A2>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Index<A2>>>) => Index<Unpack<Index<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Index<A2>>>) => Unpack<Unpack<Index<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4, A5>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number): (f: (v: Index<KeyAt<Unpack<A2>, K4>>) => Index<KeyAt<Unpack<A2>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Unpack<A2>, K4>>) => Unpack<KeyAt<Unpack<A2>, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5): (f: (v: KeyAt<Index<Unpack<A2>>, K5>) => KeyAt<Index<Unpack<A2>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number): (f: (v: Index<Index<Unpack<A2>>>) => Index<Index<Unpack<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Unpack<A2>>>) => Unpack<Index<Unpack<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Unpack<A2>>, K5>) => KeyAt<Unpack<Unpack<A2>>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Unpack<A2>>>) => Index<Unpack<Unpack<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Unpack<A2>>>) => Unpack<Unpack<Unpack<A2>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5>>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable, A5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable>, T4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Collection<T5>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4, A5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string>(i1: number, k2: K2, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, T5>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, S5, A5>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T5>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S5, A5>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, K5 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, T5>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, S5, A5>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Indexable>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4, A5>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string>(i1: number, k2: K2, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, T5>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, S5, A5>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K5 extends string>(i1: number, k2: K2, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string>(i1: number, k2: K2, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, T5>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, S5, A5>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, T4, K5 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string, T4>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, T4, T5>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, T4, S5, A5>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Indexable>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Collection<T5>, T5>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4, A5>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, T5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, S5, A5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, T3, S5, A5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, T5>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, S5, A5>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Collection<T5>, T5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4, A5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Indexable>>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable, A5>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4>, T4, A5>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Collection<T5>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4, A5>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, K5 extends string>(i1: number, i2: number, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string>(i1: number, i2: number, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, T5>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, S5, A5>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K3 extends string, K5 extends string>(i1: number, i2: number, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<K3 extends string>(i1: number, i2: number, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<K3 extends string, T5>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<K3 extends string, S5, A5>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K3 extends string, T4, K5 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<K3 extends string, T4>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<K3 extends string, T4, T5>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<K3 extends string, T4, S5, A5>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Indexable>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Collection<T5>, T5>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4, A5>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K4 extends string, K5 extends string>(i1: number, i2: number, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<K4 extends string>(i1: number, i2: number, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<K4 extends string, T5>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<K4 extends string, S5, A5>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K5 extends string>(i1: number, i2: number, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod(i1: number, i2: number, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T5>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<S5, A5>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T4, K5 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T4>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T4, T5>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T4, S5, A5>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Indexable>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Collection<T5>, T5>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4, A5>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T3, K4 extends string, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T3, K4 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T3, K4 extends string, T5>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T3, K4 extends string, S5, A5>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T3, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T3>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T3, T5>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T3, S5, A5>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T3, T4, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T3, T4>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T3, T4, T5>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T3, T4, S5, A5>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T3, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Collection<T5>, T5>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4, A5>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4>, K4 extends string, A5>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Indexable>>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Collection<T5>>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable, A5>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Indexable>, T4>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4>, T4, A5>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Collection<T5>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4, A5>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, S5, A5>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, K3 extends string, S5, A5>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, T5>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, S5, A5>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4, A5>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2, K4 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T2, K4 extends string, T5>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, K4 extends string, S5, A5>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T2, T5>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, S5, A5>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T2, T4, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2, T4>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T2, T4, T5>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, T4, S5, A5>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4, A5>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, S5, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, T3, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T2, T3, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, T3, S5, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T2, T3, T4, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T2, T3, T4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T2, T3, T4, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T2, T3, T4, S5, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends HasKey<K5>, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4, A5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Collection<T5>>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable, A5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Indexable>, T4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4>, T4, A5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Collection<T5>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4, A5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number): (f: (v: Index<KeyAt<KeyAt<A2, K3>, K4>>) => Index<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5): (f: (v: KeyAt<Index<KeyAt<A2, K3>>, K5>) => KeyAt<Index<KeyAt<A2, K3>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number): (f: (v: Index<Index<KeyAt<A2, K3>>>) => Index<Index<KeyAt<A2, K3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<KeyAt<A2, K3>>>) => Unpack<Index<KeyAt<A2, K3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<KeyAt<A2, K3>>>) => Index<Unpack<KeyAt<A2, K3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<KeyAt<A2, K3>>>) => Unpack<Unpack<KeyAt<A2, K3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Index<A2>, K4>, K5>) => KeyAt<KeyAt<Index<A2>, K4>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number): (f: (v: Index<KeyAt<Index<A2>, K4>>) => Index<KeyAt<Index<A2>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Index<A2>, K4>>) => Unpack<KeyAt<Index<A2>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5): (f: (v: KeyAt<Index<Index<A2>>, K5>) => KeyAt<Index<Index<A2>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Indexable>>>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number): (f: (v: Index<Index<Index<A2>>>) => Index<Index<Index<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Index<A2>>>) => Unpack<Index<Index<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable>, A5>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Index<A2>>, K5>) => KeyAt<Unpack<Index<A2>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Index<A2>>>) => Index<Unpack<Index<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Index<A2>>>) => Unpack<Unpack<Index<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4>>, T4, A5>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Collection<T5>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4, A5>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number): (f: (v: Index<KeyAt<Unpack<A2>, K4>>) => Index<KeyAt<Unpack<A2>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Unpack<A2>, K4>>) => Unpack<KeyAt<Unpack<A2>, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5): (f: (v: KeyAt<Index<Unpack<A2>>, K5>) => KeyAt<Index<Unpack<A2>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number): (f: (v: Index<Index<Unpack<A2>>>) => Index<Index<Unpack<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Unpack<A2>>>) => Unpack<Index<Unpack<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable>, T3, A5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Unpack<A2>>, K5>) => KeyAt<Unpack<Unpack<A2>>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Unpack<A2>>>) => Index<Unpack<Unpack<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Unpack<A2>>>) => Unpack<Unpack<Unpack<A2>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4, A5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Collection<T5>>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable, A5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Indexable>, T4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4>, T4, A5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends HasKey<K5>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Collection<T5>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4, A5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Indexable<S2>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, S5, A5>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4, A5>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, S5, A5>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4, A5>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, S5, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S5, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, S5, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4, A5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable, A5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4, A5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K3 extends string, S5, A5>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, T5>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, S5, A5>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4, A5>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, K4 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, K4 extends string, T5>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, T5>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, S5, A5>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, T4, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T4>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, T4, T5>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T4, S5, A5>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4, A5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, S5, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T3, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, T3, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T3, S5, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T3, T4, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T3, T4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, T3, T4, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T3, T4, S5, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4, A5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Collection<T5>>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Indexable>, T4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4>, T4, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4, A5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2, T4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, T4, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, T3, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, T3, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, T3, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, V>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<V>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & V>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, S5, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Collection<T5>>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable, A5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Indexable>, T4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4>, T4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4, A5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number): (f: (v: Index<KeyAt<KeyAt<A2, K3>, K4>>) => Index<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5): (f: (v: KeyAt<Index<KeyAt<A2, K3>>, K5>) => KeyAt<Index<KeyAt<A2, K3>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number): (f: (v: Index<Index<KeyAt<A2, K3>>>) => Index<Index<KeyAt<A2, K3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<KeyAt<A2, K3>>>) => Unpack<Index<KeyAt<A2, K3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<KeyAt<A2, K3>>>) => Index<Unpack<KeyAt<A2, K3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<KeyAt<A2, K3>>>) => Unpack<Unpack<KeyAt<A2, K3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Index<A2>, K4>, K5>) => KeyAt<KeyAt<Index<A2>, K4>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number): (f: (v: Index<KeyAt<Index<A2>, K4>>) => Index<KeyAt<Index<A2>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Index<A2>, K4>>) => Unpack<KeyAt<Index<A2>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5): (f: (v: KeyAt<Index<Index<A2>>, K5>) => KeyAt<Index<Index<A2>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number): (f: (v: Index<Index<Index<A2>>>) => Index<Index<Index<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Index<A2>>>) => Unpack<Index<Index<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable>, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Index<A2>>, K5>) => KeyAt<Unpack<Index<A2>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Index<A2>>>) => Index<Unpack<Index<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Index<A2>>>) => Unpack<Unpack<Index<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number): (f: (v: Index<KeyAt<Unpack<A2>, K4>>) => Index<KeyAt<Unpack<A2>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Unpack<A2>, K4>>) => Unpack<KeyAt<Unpack<A2>, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5): (f: (v: KeyAt<Index<Unpack<A2>>, K5>) => KeyAt<Index<Unpack<A2>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number): (f: (v: Index<Index<Unpack<A2>>>) => Index<Index<Unpack<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Unpack<A2>>>) => Unpack<Index<Unpack<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Unpack<A2>>, K5>) => KeyAt<Unpack<Unpack<A2>>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Unpack<A2>>>) => Index<Unpack<Unpack<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Unpack<A2>>>) => Unpack<Unpack<Unpack<A2>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Collection<T5>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Indexable>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4>, T4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Collection<T5>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4, A5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>) => KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable>>>, K2 extends string, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number): (f: (v: Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>) => Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5>>>>, K2 extends string, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>) => Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5>>>>, K2 extends string, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5): (f: (v: KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>) => KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable>>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number): (f: (v: Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>) => Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5>>>>, K2 extends string, K3 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>) => Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5>>>>, K2 extends string, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>) => KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable>>>, K2 extends string, K3 extends string, T4>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>) => Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5>>>>, K2 extends string, K3 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>) => Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5>>>>, K2 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>) => KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable>>>, K2 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number): (f: (v: Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>) => Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5>>>>, K2 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>) => Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5>>>>, K2 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5): (f: (v: KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>) => KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable>>>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number): (f: (v: Index<Index<Index<KeyAt<A1, K2>>>>) => Index<Index<Index<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5>>>>, K2 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Index<KeyAt<A1, K2>>>>) => Unpack<Index<Index<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5>>>>, K2 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>) => KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable>>>, K2 extends string, T4>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Index<KeyAt<A1, K2>>>>) => Index<Unpack<Index<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5>>>>, K2 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Index<KeyAt<A1, K2>>>>) => Unpack<Unpack<Index<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5>>>>, K2 extends string, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>) => KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable>>>, K2 extends string, T3, K4 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number): (f: (v: Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>) => Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5>>>>, K2 extends string, T3, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>) => Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5>>>>, K2 extends string, T3, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5): (f: (v: KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>) => KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable>>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number): (f: (v: Index<Index<Unpack<KeyAt<A1, K2>>>>) => Index<Index<Unpack<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>, K2 extends string, T3, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Unpack<KeyAt<A1, K2>>>>) => Unpack<Index<Unpack<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5>>>>, K2 extends string, T3, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>) => KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable>>>, K2 extends string, T3, T4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Unpack<KeyAt<A1, K2>>>>) => Index<Unpack<Unpack<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5>>>>, K2 extends string, T3, T4, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>) => Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5>>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>) => KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number): (f: (v: Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>) => Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5>>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>) => Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5>>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5): (f: (v: KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>) => KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable>>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number): (f: (v: Index<Index<KeyAt<Index<A1>, K3>>>) => Index<Index<KeyAt<Index<A1>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5>>>>, K3 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<KeyAt<Index<A1>, K3>>>) => Unpack<Index<KeyAt<Index<A1>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5>>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>) => KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable>>>, K3 extends string, T4>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<KeyAt<Index<A1>, K3>>>) => Index<Unpack<KeyAt<Index<A1>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5>>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<KeyAt<Index<A1>, K3>>>) => Unpack<Unpack<KeyAt<Index<A1>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5>>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>) => KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable>>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number): (f: (v: Index<KeyAt<Index<Index<A1>>, K4>>) => Index<KeyAt<Index<Index<A1>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5>>>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Index<Index<A1>>, K4>>) => Unpack<KeyAt<Index<Index<A1>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5>>>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5): (f: (v: KeyAt<Index<Index<Index<A1>>>, K5>) => KeyAt<Index<Index<Index<A1>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Indexable>>>>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number): (f: (v: Index<Index<Index<Index<A1>>>>) => Index<Index<Index<Index<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5>>>>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Index<Index<A1>>>>) => Unpack<Index<Index<Index<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable>>, A5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5>>>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Index<Index<A1>>>, K5>) => KeyAt<Unpack<Index<Index<A1>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable>>>, T4>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Index<Index<A1>>>>) => Index<Unpack<Index<Index<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5>>>>, T4, T5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Index<Index<A1>>>>) => Unpack<Unpack<Index<Index<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4, A5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5>>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>) => KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number): (f: (v: Index<KeyAt<Unpack<Index<A1>>, K4>>) => Index<KeyAt<Unpack<Index<A1>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5>>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Unpack<Index<A1>>, K4>>) => Unpack<KeyAt<Unpack<Index<A1>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5>>>>, T3, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5): (f: (v: KeyAt<Index<Unpack<Index<A1>>>, K5>) => KeyAt<Index<Unpack<Index<A1>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable>>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number): (f: (v: Index<Index<Unpack<Index<A1>>>>) => Index<Index<Unpack<Index<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5>>>>, T3, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Unpack<Index<A1>>>>) => Unpack<Index<Unpack<Index<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5>>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Unpack<Index<A1>>>, K5>) => KeyAt<Unpack<Unpack<Index<A1>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable>>>, T3, T4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Unpack<Index<A1>>>>) => Index<Unpack<Unpack<Index<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5>>>>, T3, T4, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Unpack<Index<A1>>>>) => Unpack<Unpack<Unpack<Index<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4, A5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5>>>>, T2, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>) => KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable>>>, T2, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number): (f: (v: Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>) => Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5>>>>, T2, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>) => Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5>>>>, T2, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5): (f: (v: KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>) => KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable>>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number): (f: (v: Index<Index<KeyAt<Unpack<A1>, K3>>>) => Index<Index<KeyAt<Unpack<A1>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5>>>>, T2, K3 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<KeyAt<Unpack<A1>, K3>>>) => Unpack<Index<KeyAt<Unpack<A1>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5>>>>, T2, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>) => KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable>>>, T2, K3 extends string, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<KeyAt<Unpack<A1>, K3>>>) => Index<Unpack<KeyAt<Unpack<A1>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5>>>>, T2, K3 extends string, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>) => Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5>>>>, T2, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>) => KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable>>>, T2, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number): (f: (v: Index<KeyAt<Index<Unpack<A1>>, K4>>) => Index<KeyAt<Index<Unpack<A1>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5>>>>, T2, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Index<Unpack<A1>>, K4>>) => Unpack<KeyAt<Index<Unpack<A1>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5>>>>, T2, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5): (f: (v: KeyAt<Index<Index<Unpack<A1>>>, K5>) => KeyAt<Index<Index<Unpack<A1>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable>>>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number): (f: (v: Index<Index<Index<Unpack<A1>>>>) => Index<Index<Index<Unpack<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5>>>>, T2, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Index<Unpack<A1>>>>) => Unpack<Index<Index<Unpack<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5>>>>, T2, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Index<Unpack<A1>>>, K5>) => KeyAt<Unpack<Index<Unpack<A1>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable>>>, T2, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Index<Unpack<A1>>>>) => Index<Unpack<Index<Unpack<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5>>>>, T2, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Index<Unpack<A1>>>>) => Unpack<Unpack<Index<Unpack<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5>>>>, T2, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>) => KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable>>>, T2, T3, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number): (f: (v: Index<KeyAt<Unpack<Unpack<A1>>, K4>>) => Index<KeyAt<Unpack<Unpack<A1>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5>>>>, T2, T3, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>) => Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5>>>>, T2, T3, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5): (f: (v: KeyAt<Index<Unpack<Unpack<A1>>>, K5>) => KeyAt<Index<Unpack<Unpack<A1>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable>>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number): (f: (v: Index<Index<Unpack<Unpack<A1>>>>) => Index<Index<Unpack<Unpack<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5>>>>, T2, T3, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Unpack<Unpack<A1>>>>) => Unpack<Index<Unpack<Unpack<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5>>>>, T2, T3, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>) => KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable>>>, T2, T3, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Unpack<Unpack<A1>>>>) => Index<Unpack<Unpack<Unpack<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5>>>>, T2, T3, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Unpack<Unpack<A1>>>>) => Unpack<Unpack<Unpack<Unpack<A1>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4, A5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number): (f: (v: Index<KeyAt<KeyAt<A2, K3>, K4>>) => Index<KeyAt<KeyAt<A2, K3>, K4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => Unpack<KeyAt<KeyAt<A2, K3>, K4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5): (f: (v: KeyAt<Index<KeyAt<A2, K3>>, K5>) => KeyAt<Index<KeyAt<A2, K3>>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number): (f: (v: Index<Index<KeyAt<A2, K3>>>) => Index<Index<KeyAt<A2, K3>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<KeyAt<A2, K3>>>) => Unpack<Index<KeyAt<A2, K3>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => KeyAt<Unpack<KeyAt<A2, K3>>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<KeyAt<A2, K3>>>) => Index<Unpack<KeyAt<A2, K3>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<KeyAt<A2, K3>>>) => Unpack<Unpack<KeyAt<A2, K3>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Index<A2>, K4>, K5>) => KeyAt<KeyAt<Index<A2>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number): (f: (v: Index<KeyAt<Index<A2>, K4>>) => Index<KeyAt<Index<A2>, K4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Index<A2>, K4>>) => Unpack<KeyAt<Index<A2>, K4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5): (f: (v: KeyAt<Index<Index<A2>>, K5>) => KeyAt<Index<Index<A2>>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number): (f: (v: Index<Index<Index<A2>>>) => Index<Index<Index<A2>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Collection<T5>>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Index<A2>>>) => Unpack<Index<Index<A2>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable>, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Index<A2>>, K5>) => KeyAt<Unpack<Index<A2>>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Indexable>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Index<A2>>>) => Index<Unpack<Index<A2>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Index<A2>>>) => Unpack<Unpack<Index<A2>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => KeyAt<KeyAt<Unpack<A2>, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number): (f: (v: Index<KeyAt<Unpack<A2>, K4>>) => Index<KeyAt<Unpack<A2>, K4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<Unpack<A2>, K4>>) => Unpack<KeyAt<Unpack<A2>, K4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5): (f: (v: KeyAt<Index<Unpack<A2>>, K5>) => KeyAt<Index<Unpack<A2>>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Indexable>>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number): (f: (v: Index<Index<Unpack<A2>>>) => Index<Index<Unpack<A2>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<Unpack<A2>>>) => Unpack<Index<Unpack<A2>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<Unpack<A2>>, K5>) => KeyAt<Unpack<Unpack<A2>>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<Unpack<A2>>>) => Index<Unpack<Unpack<A2>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<Unpack<A2>>>) => Unpack<Unpack<Unpack<A2>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5): (f: (v: KeyAt<KeyAt<A3, K4>, K5>) => KeyAt<KeyAt<A3, K4>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Indexable>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number): (f: (v: Index<KeyAt<A3, K4>>) => Index<KeyAt<A3, K4>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>): (f: (v: Unpack<KeyAt<A3, K4>>) => Unpack<KeyAt<A3, K4>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5): (f: (v: KeyAt<Index<A3>, K5>) => KeyAt<Index<A3>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number): (f: (v: Index<Index<A3>>) => Index<Index<A3>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Collection<T5>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>): (f: (v: Unpack<Index<A3>>) => Unpack<Index<A3>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5): (f: (v: KeyAt<Unpack<A3>, K5>) => KeyAt<Unpack<A3>, K5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Indexable>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number): (f: (v: Index<Unpack<A3>>) => Index<Unpack<A3>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>): (f: (v: Unpack<Unpack<A3>>) => Unpack<Unpack<A3>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4>, T4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends HasKey<K5>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5): (f: (v: KeyAt<A4, K5>) => KeyAt<A4, K5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number): (f: (v: Index<A4>) => Index<A4>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Collection<T5>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>): (f: (v: Unpack<A4>) => Unpack<A4>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4, A5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>): (f: (v: A5) => A5) => (s: S1) => S1

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T6>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, T6>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K5 extends string>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T6>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T5>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T5, T6>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T5, S6, A6>(k1: K1, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S5, A5, A6>(k1: K1, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, T5>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, T5, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, T5, S6, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, T4, S5, A5, A6>(k1: K1, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K3 extends string, S4, A4, A5, A6>(k1: K1, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, T6>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, T5>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, T5, T6>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K5 extends string>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K5 extends string, T6>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string>(k1: K1, k2: K2, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T6>(k1: K1, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T5, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T5>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T5, T6>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T5, S6, A6>(k1: K1, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S5, A5, A6>(k1: K1, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, K5 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, K5 extends string, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, T5, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, T5>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, T5, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, T5, S6, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T4, S5, A5, A6>(k1: K1, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S4, A4, A5, A6>(k1: K1, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, T5>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K4 extends string, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T5>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, K5 extends string, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, T5>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, T5, S6, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, S5, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, T4, S5, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Indexable, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4, A5 extends Indexable>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, T3, S4, A4, A5, A6>(k1: K1, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Indexable, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Indexable, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4, A5 extends Indexable>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K2 extends string, S3, A3, A4, A5, A6>(k1: K1, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, HasKey<K2, S3>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, T6>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, T5>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, T5, T6>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, T5, S6, A6>(k1: K1, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K5 extends string>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K5 extends string, T6>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string>(k1: K1, i2: number, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T6>(k1: K1, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T5, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T5>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T5, T6>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T5, S6, A6>(k1: K1, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S5, A5, A6>(k1: K1, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, K5 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, K5 extends string, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, T5, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, T5>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, T5, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, T5, S6, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, T4, S5, A5, A6>(k1: K1, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K3 extends string, S4, A4, A5, A6>(k1: K1, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, K5 extends string>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string>(k1: K1, i2: number, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, T6>(k1: K1, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, T5>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, T5, T6>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, T5, S6, A6>(k1: K1, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K4 extends string, S5, A5, A6>(k1: K1, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, K5 extends string>(k1: K1, i2: number, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, K5 extends string, T6>(k1: K1, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string>(k1: K1, i2: number, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T6>(k1: K1, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, S6, A6>(k1: K1, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T5, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T5>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T5, T6>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T5, S6, A6>(k1: K1, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, S5, A5, A6>(k1: K1, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4, K5 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4, K5 extends string, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4, K5 extends string, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T4, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T4, T5, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4, T5>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4, T5, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T4, T5, S6, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T4, S5, A5 extends Indexable>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T4, S5, A5, A6>(k1: K1, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Indexable, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4, A5 extends Indexable>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, S4, A4, A5, A6>(k1: K1, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, T5>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, K4 extends string, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T5>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, K5 extends string, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, T5>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, T5, S6, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, S5, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, T4, S5, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Indexable, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4, A5 extends Indexable>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T3, S4, A4, A5, A6>(k1: K1, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Indexable, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Indexable, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4, A5 extends Indexable>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, S3, A3, A4, A5, A6>(k1: K1, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Indexable<S3>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T5>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, T5>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K3 extends string, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T5>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, T5>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K4 extends string, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, K5 extends string, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, T5, S6, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, S5, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, S5, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, T4, S5, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, T3, S4, A4, A5, A6>(k1: K1, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Indexable>, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Indexable, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Indexable<Indexable>>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Indexable, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4, A5 extends Indexable>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, T2, S3, A3, A4, A5, A6>(k1: K1, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, Collection<T2 & S3>>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<KeyAt<A2, K3>>>>) => Index<Index<Index<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<KeyAt<A2, K3>>>>) => Unpack<Index<Index<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<KeyAt<A2, K3>>>>) => Index<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<KeyAt<A2, K3>>>>) => Index<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Index<A2>, K4>>>) => Index<Index<KeyAt<Index<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Index<A2>, K4>>>) => Unpack<Index<KeyAt<Index<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Index<A2>, K4>>>) => Index<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Index<A2>>, K5>>) => Index<KeyAt<Index<Index<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Index<A2>>, K5>>) => Unpack<KeyAt<Index<Index<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Index<A2>>>, K6>) => KeyAt<Index<Index<Index<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Index<A2>>>>) => Index<Index<Index<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Index<A2>>>>) => Unpack<Index<Index<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Indexable>>, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Index<A2>>>, K6>) => KeyAt<Unpack<Index<Index<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Index<A2>>>>) => Index<Unpack<Index<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Index<A2>>>>) => Unpack<Unpack<Index<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Indexable>, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Index<A2>>, K5>>) => Index<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Index<A2>>>, K6>) => KeyAt<Index<Unpack<Index<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Index<A2>>>>) => Index<Index<Unpack<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Index<A2>>>>) => Unpack<Index<Unpack<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Index<A2>>>>) => Index<Unpack<Unpack<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Index<A2>>>>) => Unpack<Unpack<Unpack<Index<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Indexable, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Unpack<A2>, K4>>>) => Index<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Unpack<A2>>, K5>>) => Index<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Unpack<A2>>>, K6>) => KeyAt<Index<Index<Unpack<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Unpack<A2>>>>) => Index<Index<Index<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Unpack<A2>>>>) => Unpack<Index<Index<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Unpack<A2>>>>) => Index<Unpack<Index<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Unpack<A2>>>>) => Unpack<Unpack<Index<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Unpack<A2>>>>) => Index<Index<Unpack<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Unpack<A2>>>>) => Unpack<Index<Unpack<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Unpack<A2>>>>) => Index<Unpack<Unpack<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Unpack<A2>>>>) => Unpack<Unpack<Unpack<Unpack<A2>>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2 extends Collection<T3>, T3, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Indexable<Indexable>>>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Indexable>, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Indexable, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3 extends Collection<T4>, T4, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Indexable<Indexable>>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Indexable, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4 extends Collection<T5>, T5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4, A5 extends Indexable>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4, A5 extends Collection<T6>, T6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K1 extends string, S2, A2, A3, A4, A5, A6>(k1: K1, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends HasKey<K1, S2>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, T6>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, T5>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, T5, T6>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(i1: number, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(i1: number, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K5 extends string>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K5 extends string, T6>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string>(i1: number, k2: K2, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T6>(i1: number, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T5, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T5>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T5, T6>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T5, S6, A6>(i1: number, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S5, A5, A6>(i1: number, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, K5 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, K5 extends string, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, T5, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, T5>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, T5, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, T5, S6, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, T4, S5, A5, A6>(i1: number, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K3 extends string, S4, A4, A5, A6>(i1: number, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, K5 extends string>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string>(i1: number, k2: K2, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, T6>(i1: number, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, T5>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, T5, T6>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, T5, S6, A6>(i1: number, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K4 extends string, S5, A5, A6>(i1: number, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, K5 extends string>(i1: number, k2: K2, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, K5 extends string, T6>(i1: number, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string>(i1: number, k2: K2, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T6>(i1: number, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, S6, A6>(i1: number, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, T5, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T5>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T5, T6>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T5, S6, A6>(i1: number, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, S5, A5, A6>(i1: number, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4, K5 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4, K5 extends string, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4, K5 extends string, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, T4, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, T4, T5, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4, T5>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4, T5, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T4, T5, S6, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, T4, S5, A5 extends Indexable>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, T4, S5, A5, A6>(i1: number, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Indexable, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4, A5 extends Indexable>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, S4, A4, A5, A6>(i1: number, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, T5>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, K4 extends string, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T5>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, K5 extends string, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, T5>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, T5, S6, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, S5, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, T4, S5, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Indexable, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4, A5 extends Indexable>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, T3, S4, A4, A5, A6>(i1: number, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Indexable, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Indexable, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4, A5 extends Indexable>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K2 extends string, S3, A3, A4, A5, A6>(i1: number, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<HasKey<K2, S3>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, K5 extends string>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string>(i1: number, i2: number, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, T6>(i1: number, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, T5>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, T5, T6>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, T5, S6, A6>(i1: number, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K3 extends string, K4 extends string, S5, A5, A6>(i1: number, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<K3 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string, K5 extends string>(i1: number, i2: number, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, K5 extends string, T6>(i1: number, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K3 extends string, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string>(i1: number, i2: number, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, T6>(i1: number, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, S6, A6>(i1: number, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<K3 extends string, T5, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string, T5>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, T5, T6>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, T5, S6, A6>(i1: number, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K3 extends string, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K3 extends string, S5, A5, A6>(i1: number, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4, K5 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4, K5 extends string, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4, K5 extends string, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K3 extends string, T4, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<K3 extends string, T4, T5, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4, T5>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4, T5, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K3 extends string, T4, T5, S6, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K3 extends string, T4, S5, A5 extends Indexable>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K3 extends string, T4, S5, A5, A6>(i1: number, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Indexable, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4, A5 extends Indexable>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K3 extends string, S4, A4, A5, A6>(i1: number, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K4 extends string, K5 extends string>(i1: number, i2: number, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K4 extends string, K5 extends string, T6>(i1: number, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K4 extends string, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K4 extends string>(i1: number, i2: number, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<K4 extends string, T6>(i1: number, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K4 extends string, S6, A6>(i1: number, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<K4 extends string, T5, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K4 extends string, T5>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<K4 extends string, T5, T6>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K4 extends string, T5, S6, A6>(i1: number, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K4 extends string, S5, A5, A6>(i1: number, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<K5 extends string>(i1: number, i2: number, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<K5 extends string, T6>(i1: number, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<K5 extends string, S6, A6>(i1: number, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<K6 extends string>(i1: number, i2: number, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod(i1: number, i2: number, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T6>(i1: number, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<S6, A6>(i1: number, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T5, K6 extends string>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T5>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T5, T6>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T5, S6, A6>(i1: number, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<S5, A5 extends Indexable>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<S5, A5, A6>(i1: number, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T4, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T4, K5 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T4, K5 extends string, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T4, K5 extends string, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T4, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T4>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T4, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T4, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T4, T5, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T4, T5>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T4, T5, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T4, T5, S6, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T4, S5, A5 extends Indexable>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T4, S5, A5, A6>(i1: number, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Indexable, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4, A5 extends Indexable>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<S4, A4, A5, A6>(i1: number, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T3, K4 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T3, K4 extends string, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string, T5>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, K4 extends string, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T3, K4 extends string, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T3, K4 extends string, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T3, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T3, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T3, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T3, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T3, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3, T5>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T3, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T3, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T3, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T3, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T3, T4, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3, T4, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T3, T4, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, T4, K5 extends string, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T3, T4, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3, T4>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T3, T4, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, T4, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T3, T4, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T3, T4, T5>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T3, T4, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T3, T4, T5, S6, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T3, T4, S5, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T3, T4, S5, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Indexable<Indexable>>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Indexable, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4, A5 extends Indexable>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T3, S4, A4, A5, A6>(i1: number, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Indexable>, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Indexable, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Indexable<Indexable>>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Indexable, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4, A5 extends Indexable>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<S3, A3, A4, A5, A6>(i1: number, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Indexable<S3>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T5>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, T5>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K3 extends string, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T2, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T2, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string, T5>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T2, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T5>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T2, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T2, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T2, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T2, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T4, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, T4, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T4>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T4, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T4, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T2, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T4, T5>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T4, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, T3, K4 extends string, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T2, T3, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, T3, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T2, T3, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T2, T3, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T2, T3, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T2, T3, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T2, T3, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3, T4, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, T4, K5 extends string, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T2, T3, T4, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3, T4>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, T4, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, T4, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T2, T3, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T2, T3, T4, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T2, T3, T4, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T2, T3, T4, T5, S6, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, T3, T4, S5, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, T3, T4, S5, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, T3, T4, S5, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, T3, S4, A4, A5, A6>(i1: number, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Indexable<Indexable>>>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Indexable>, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Indexable, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3 extends Collection<T4>, T4, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Indexable<Indexable>>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Indexable, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4 extends Collection<T5>, T5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4, A5 extends Indexable>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4, A5 extends Collection<T6>, T6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<T2, S3, A3, A4, A5, A6>(i1: number, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<Collection<T2 & S3>>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<KeyAt<A2, K3>>>>) => Index<Index<Index<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<KeyAt<A2, K3>>>>) => Unpack<Index<Index<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<KeyAt<A2, K3>>>>) => Index<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<KeyAt<A2, K3>>>>) => Index<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Index<A2>, K4>>>) => Index<Index<KeyAt<Index<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Index<A2>, K4>>>) => Unpack<Index<KeyAt<Index<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Index<A2>, K4>>>) => Index<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Index<A2>>, K5>>) => Index<KeyAt<Index<Index<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Index<A2>>, K5>>) => Unpack<KeyAt<Index<Index<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Index<A2>>>, K6>) => KeyAt<Index<Index<Index<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Index<A2>>>>) => Index<Index<Index<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Index<A2>>>>) => Unpack<Index<Index<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Indexable>>, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Index<A2>>>, K6>) => KeyAt<Unpack<Index<Index<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Index<A2>>>>) => Index<Unpack<Index<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Index<A2>>>>) => Unpack<Unpack<Index<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Indexable>, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Index<A2>>, K5>>) => Index<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Index<A2>>>, K6>) => KeyAt<Index<Unpack<Index<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Index<A2>>>>) => Index<Index<Unpack<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Index<A2>>>>) => Unpack<Index<Unpack<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Index<A2>>>>) => Index<Unpack<Unpack<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Index<A2>>>>) => Unpack<Unpack<Unpack<Index<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Indexable, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Unpack<A2>, K4>>>) => Index<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Unpack<A2>>, K5>>) => Index<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Unpack<A2>>>, K6>) => KeyAt<Index<Index<Unpack<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Unpack<A2>>>>) => Index<Index<Index<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Unpack<A2>>>>) => Unpack<Index<Index<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Unpack<A2>>>>) => Index<Unpack<Index<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Unpack<A2>>>>) => Unpack<Unpack<Index<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Unpack<A2>>>>) => Index<Index<Unpack<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Unpack<A2>>>>) => Unpack<Index<Unpack<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Unpack<A2>>>>) => Index<Unpack<Unpack<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Unpack<A2>>>>) => Unpack<Unpack<Unpack<Unpack<A2>>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2 extends Collection<T3>, T3, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Indexable<Indexable>>>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Indexable>, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Indexable, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3 extends Collection<T4>, T4, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Indexable<Indexable>>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Indexable, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4 extends Collection<T5>, T5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4, A5 extends Indexable>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4, A5 extends Collection<T6>, T6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Indexable<S2>>(s: S) => S

export function mod<S2, A2, A3, A4, A5, A6>(i1: number, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Indexable<S2>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T5>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T5>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, T5>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Indexable<S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, T5, S6, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, T4, S5, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, T3, S4, A4, A5, A6>(t1: Traversal<T1>, k2: K2, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K2 extends string, S3, A3, A4, A5, A6>(t1: Traversal<T1>, k2: K2, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & HasKey<K2, S3>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T5>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, T5>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string, T5>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T5>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T4, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T4, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T4>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T4, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T4, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T4, T5>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T4, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Indexable<S4>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T3, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T3, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T3, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3, T4, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T3, T4, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3, T4>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, T4, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, T4, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T3, T4, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T3, T4, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T3, T4, T5, S6, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T3, T4, S5, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T3, S4, A4, A5, A6>(t1: Traversal<T1>, i2: number, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, S3, A3, A4, A5, A6>(t1: Traversal<T1>, i2: number, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Indexable<S3>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K3 extends string, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, k3: K3, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & HasKey<K3, S4>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T4>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, i3: number, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Indexable<S4>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, T3, K4 extends string, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & HasKey<K4, S5>>>>>(s: S) => S

export function mod<T1, T2, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, T3, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, T3, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, T3, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Indexable<S5>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, K5 extends string, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Indexable<S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6, V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable<V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): <V>(f: (v: V) => V) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6 & V>>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, T5, S6, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<S6, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & S6>>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, S5, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, S5, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, S5, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, T3, T4, S5, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<S5, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & Collection<T4 & S5>>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, T3, S4, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<S4, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & Collection<T3 & S4>>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, T2, S3, A3, A4, A5, A6>(t1: Traversal<T1>, t2: Traversal<T2>, l3: Lens<S3, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & Collection<T2 & S3>>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<KeyAt<A2, K3>>>>) => Index<Index<Index<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<KeyAt<A2, K3>>>>) => Unpack<Index<Index<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<KeyAt<A2, K3>>>>) => Index<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<KeyAt<A2, K3>>>>) => Index<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Index<A2>, K4>>>) => Index<Index<KeyAt<Index<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Index<A2>, K4>>>) => Unpack<Index<KeyAt<Index<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Index<A2>, K4>>>) => Index<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Index<A2>>, K5>>) => Index<KeyAt<Index<Index<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Index<A2>>, K5>>) => Unpack<KeyAt<Index<Index<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Index<A2>>>, K6>) => KeyAt<Index<Index<Index<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Index<A2>>>>) => Index<Index<Index<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Index<A2>>>>) => Unpack<Index<Index<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Indexable>>, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Index<A2>>>, K6>) => KeyAt<Unpack<Index<Index<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Index<A2>>>>) => Index<Unpack<Index<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Index<A2>>>>) => Unpack<Unpack<Index<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable>, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Indexable>, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Index<A2>>, K5>>) => Index<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Index<A2>>>, K6>) => KeyAt<Index<Unpack<Index<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Index<A2>>>>) => Index<Index<Unpack<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Index<A2>>>>) => Unpack<Index<Unpack<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Index<A2>>>>) => Index<Unpack<Unpack<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Index<A2>>>>) => Unpack<Unpack<Unpack<Index<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Indexable, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Unpack<A2>, K4>>>) => Index<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Unpack<A2>>, K5>>) => Index<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Unpack<A2>>>, K6>) => KeyAt<Index<Index<Unpack<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Unpack<A2>>>>) => Index<Index<Index<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Unpack<A2>>>>) => Unpack<Index<Index<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Unpack<A2>>>>) => Index<Unpack<Index<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Unpack<A2>>>>) => Unpack<Unpack<Index<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Unpack<A2>>>>) => Index<Index<Unpack<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Unpack<A2>>>>) => Unpack<Index<Unpack<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Unpack<A2>>>>) => Index<Unpack<Unpack<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Unpack<A2>>>>) => Unpack<Unpack<Unpack<Unpack<A2>>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2 extends Collection<T3>, T3, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Indexable<Indexable>>>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Indexable>, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Indexable, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3 extends Collection<T4>, T4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Indexable<Indexable>>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Indexable, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4 extends Collection<T5>, T5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4, A5 extends Indexable>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4, A5 extends Collection<T6>, T6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<T1, S2, A2, A3, A4, A5, A6>(t1: Traversal<T1>, l2: Lens<S2, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => <S extends Collection<T1 & S2>>(s: S) => S

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>>) => Index<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>>) => Unpack<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, HasKey<K5>>>>, K2 extends string, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, K6>) => KeyAt<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, K2 extends string, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => Index<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => Unpack<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Indexable>>>, K2 extends string, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, K6>) => KeyAt<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => Index<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => Unpack<Unpack<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4, Collection<T5>>>>, K2 extends string, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, HasKey<K4>>>, K2 extends string, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<KeyAt<A1, K2>, K3>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>, K6>) => KeyAt<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => Index<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => Unpack<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<HasKey<K5>>>>, K2 extends string, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<KeyAt<A1, K2>, K3>>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => KeyAt<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<Indexable>>>>, K2 extends string, K3 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => Index<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => Unpack<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Indexable>>>, K2 extends string, K3 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<KeyAt<A1, K2>, K3>>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => KeyAt<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => Index<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => Unpack<Unpack<Index<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable<Collection<T5>>>>, K2 extends string, K3 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Indexable>>, K2 extends string, K3 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, i4: number, l5: Lens<Index<KeyAt<KeyAt<A1, K2>, K3>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>, K6>) => KeyAt<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => Index<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => Unpack<KeyAt<Unpack<KeyAt<KeyAt<A1, K2>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & HasKey<K5>>>>, K2 extends string, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => KeyAt<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, K2 extends string, K3 extends string, T4>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => Index<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, K3 extends string, T4, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => Unpack<Index<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Indexable>>>, K2 extends string, K3 extends string, T4, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => KeyAt<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, K3 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => Index<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => Unpack<Unpack<Unpack<KeyAt<KeyAt<A1, K2>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4 & Collection<T5>>>>, K2 extends string, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3, Collection<T4>>>, K2 extends string, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, HasKey<K3>>, K2 extends string, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, k3: K3, l4: Lens<KeyAt<KeyAt<A1, K2>, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>>) => Index<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, HasKey<K5>>>>, K2 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<KeyAt<A1, K2>>, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>, K6>) => KeyAt<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<Indexable>>>>, K2 extends string, K4 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => Index<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => Unpack<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Indexable>>>, K2 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<KeyAt<A1, K2>>, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => Index<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => Unpack<Unpack<KeyAt<Index<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4, Collection<T5>>>>, K2 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<HasKey<K4>>>, K2 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, k4: K4, l5: Lens<KeyAt<Index<KeyAt<A1, K2>>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>, K6>) => KeyAt<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, Indexable>>>>, K2 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>>) => Index<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>>) => Unpack<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<HasKey<K5>>>>, K2 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<KeyAt<A1, K2>>>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Index<KeyAt<A1, K2>>>>, K6>) => KeyAt<Index<Index<Index<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<Indexable>>>>, K2 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Index<KeyAt<A1, K2>>>>>) => Index<Index<Index<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable<Collection<T6>>>>>, K2 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Index<KeyAt<A1, K2>>>>>) => Unpack<Index<Index<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Indexable>>>, K2 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<KeyAt<A1, K2>>>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Index<KeyAt<A1, K2>>>>, K6>) => KeyAt<Unpack<Index<Index<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & Indexable>>>>, K2 extends string, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Index<KeyAt<A1, K2>>>>>) => Index<Unpack<Index<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Index<KeyAt<A1, K2>>>>>) => Unpack<Unpack<Index<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable<Collection<T5>>>>, K2 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Indexable>>, K2 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, i4: number, l5: Lens<Index<Index<KeyAt<A1, K2>>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>>) => Index<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>>) => Unpack<KeyAt<Unpack<Index<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & HasKey<K5>>>>, K2 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Index<KeyAt<A1, K2>>>>, K6>) => KeyAt<Index<Unpack<Index<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<Indexable>>>>, K2 extends string, T4>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Index<KeyAt<A1, K2>>>>>) => Index<Index<Unpack<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, T4, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Index<KeyAt<A1, K2>>>>>) => Unpack<Index<Unpack<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Indexable>>>, K2 extends string, T4, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Index<KeyAt<A1, K2>>>>, K6>) => KeyAt<Unpack<Unpack<Index<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, T4, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Index<KeyAt<A1, K2>>>>>) => Index<Unpack<Unpack<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Index<KeyAt<A1, K2>>>>>) => Unpack<Unpack<Unpack<Index<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4 & Collection<T5>>>>, K2 extends string, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable<Collection<T4>>>, K2 extends string, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Indexable>, K2 extends string, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, i3: number, l4: Lens<Index<KeyAt<A1, K2>>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, K2 extends string, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>>) => Index<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Unpack<KeyAt<A1, K2>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, HasKey<K5>>>>, K2 extends string, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>, K6>) => KeyAt<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, K2 extends string, T3, K4 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => Index<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, K2 extends string, T3, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => Unpack<Index<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Indexable>>>, K2 extends string, T3, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, K2 extends string, T3, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => Index<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => Unpack<Unpack<KeyAt<Unpack<KeyAt<A1, K2>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4, Collection<T5>>>>, K2 extends string, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & HasKey<K4>>>, K2 extends string, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>, K6>) => KeyAt<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, K2 extends string, T3, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>>) => Index<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>>) => Unpack<KeyAt<Index<Unpack<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<HasKey<K5>>>>, K2 extends string, T3, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, K2 extends string, T3, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Unpack<KeyAt<A1, K2>>>>, K6>) => KeyAt<Index<Index<Unpack<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<Indexable>>>>, K2 extends string, T3>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Unpack<KeyAt<A1, K2>>>>>) => Index<Index<Index<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, K2 extends string, T3, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Unpack<KeyAt<A1, K2>>>>>) => Unpack<Index<Index<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Indexable>>>, K2 extends string, T3, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Unpack<KeyAt<A1, K2>>>>, K6>) => KeyAt<Unpack<Index<Unpack<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, K2 extends string, T3, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Unpack<KeyAt<A1, K2>>>>>) => Index<Unpack<Index<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Unpack<KeyAt<A1, K2>>>>>) => Unpack<Unpack<Index<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable<Collection<T5>>>>, K2 extends string, T3, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Indexable>>, K2 extends string, T3, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K2 extends string, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, K2 extends string, T3, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>>) => Index<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, K2 extends string, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>>) => Unpack<KeyAt<Unpack<Unpack<KeyAt<A1, K2>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & HasKey<K5>>>>, K2 extends string, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, K2 extends string, T3, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Unpack<KeyAt<A1, K2>>>>, K6>) => KeyAt<Index<Unpack<Unpack<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, K2 extends string, T3, T4>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Unpack<KeyAt<A1, K2>>>>>) => Index<Index<Unpack<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, K2 extends string, T3, T4, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Unpack<KeyAt<A1, K2>>>>>) => Unpack<Index<Unpack<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Indexable>>>, K2 extends string, T3, T4, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K2 extends string, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>, K6>) => KeyAt<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, K2 extends string, T3, T4, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>>) => Index<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, K2 extends string, T3, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>>) => Unpack<Unpack<Unpack<Unpack<KeyAt<A1, K2>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4 & Collection<T5>>>>, K2 extends string, T3, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3 & Collection<T4>>>, K2 extends string, T3, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2, Collection<T3>>, K2 extends string, T3, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends HasKey<K2>, K2 extends string, A3, A4, A5, A6>(l1: Lens<S1, A1>, k2: K2, l3: Lens<KeyAt<A1, K2>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>>) => Index<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>>) => Unpack<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, HasKey<K5>>>>, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<Index<A1>, K3>, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>, K6>) => KeyAt<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => Index<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => Unpack<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Indexable>>>, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<Index<A1>, K3>, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>, K6>) => KeyAt<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => Index<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => Unpack<Unpack<KeyAt<KeyAt<Index<A1>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4, Collection<T5>>>>, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, HasKey<K4>>>, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<Index<A1>, K3>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>, K6>) => KeyAt<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>>) => Index<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>>) => Unpack<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<HasKey<K5>>>>, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<Index<A1>, K3>>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<KeyAt<Index<A1>, K3>>>, K6>) => KeyAt<Index<Index<KeyAt<Index<A1>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<Indexable>>>>, K3 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<KeyAt<Index<A1>, K3>>>>) => Index<Index<Index<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, K3 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<KeyAt<Index<A1>, K3>>>>) => Unpack<Index<Index<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Indexable>>>, K3 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<Index<A1>, K3>>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<KeyAt<Index<A1>, K3>>>, K6>) => KeyAt<Unpack<Index<KeyAt<Index<A1>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, K3 extends string, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<KeyAt<Index<A1>, K3>>>>) => Index<Unpack<Index<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, K3 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<KeyAt<Index<A1>, K3>>>>) => Unpack<Unpack<Index<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable<Collection<T5>>>>, K3 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Indexable>>, K3 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, i4: number, l5: Lens<Index<KeyAt<Index<A1>, K3>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>, K6>) => KeyAt<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>>) => Index<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>>) => Unpack<KeyAt<Unpack<KeyAt<Index<A1>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & HasKey<K5>>>>, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<KeyAt<Index<A1>, K3>>>, K6>) => KeyAt<Index<Unpack<KeyAt<Index<A1>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, K3 extends string, T4>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<KeyAt<Index<A1>, K3>>>>) => Index<Index<Unpack<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, K3 extends string, T4, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<KeyAt<Index<A1>, K3>>>>) => Unpack<Index<Unpack<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Indexable>>>, K3 extends string, T4, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<KeyAt<Index<A1>, K3>>>, K6>) => KeyAt<Unpack<Unpack<KeyAt<Index<A1>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<KeyAt<Index<A1>, K3>>>>) => Index<Unpack<Unpack<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<KeyAt<Index<A1>, K3>>>>) => Unpack<Unpack<Unpack<KeyAt<Index<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4 & Collection<T5>>>>, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3, Collection<T4>>>, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<HasKey<K3>>, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, k3: K3, l4: Lens<KeyAt<Index<A1>, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>>) => Index<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, HasKey<K5>>>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<Index<A1>>, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Index<Index<A1>>, K4>>, K6>) => KeyAt<Index<KeyAt<Index<Index<A1>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<Indexable>>>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Index<Index<A1>>, K4>>>) => Index<Index<KeyAt<Index<Index<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Index<Index<A1>>, K4>>>) => Unpack<Index<KeyAt<Index<Index<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Indexable>>>, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<Index<A1>>, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Index<Index<A1>>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Index<Index<A1>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Index<Index<A1>>, K4>>>) => Index<Unpack<KeyAt<Index<Index<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Index<Index<A1>>, K4>>>) => Unpack<Unpack<KeyAt<Index<Index<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4, Collection<T5>>>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<HasKey<K4>>>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, k4: K4, l5: Lens<KeyAt<Index<Index<A1>>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Index<Index<A1>>>, K5>, K6>) => KeyAt<KeyAt<Index<Index<Index<A1>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, Indexable>>>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Index<Index<A1>>>, K5>>) => Index<KeyAt<Index<Index<Index<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Index<Index<A1>>>, K5>>) => Unpack<KeyAt<Index<Index<Index<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<HasKey<K5>>>>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<Index<A1>>>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Indexable<HasKey<K6>>>>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Index<Index<A1>>>>, K6>) => KeyAt<Index<Index<Index<Index<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Indexable<Indexable>>>>>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Index<Index<A1>>>>>) => Index<Index<Index<Index<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Indexable<Collection<T6>>>>>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Index<Index<A1>>>>>) => Unpack<Index<Index<Index<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Indexable>>>, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<Index<A1>>>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Index<Index<A1>>>>, K6>) => KeyAt<Unpack<Index<Index<Index<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & Indexable>>>>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Index<Index<A1>>>>>) => Index<Unpack<Index<Index<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Index<Index<A1>>>>>) => Unpack<Unpack<Index<Index<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable<Collection<T5>>>>, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable>>, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Indexable>>, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, i4: number, l5: Lens<Index<Index<Index<A1>>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Index<Index<A1>>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Index<Index<A1>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Index<Index<A1>>>, K5>>) => Index<KeyAt<Unpack<Index<Index<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Index<Index<A1>>>, K5>>) => Unpack<KeyAt<Unpack<Index<Index<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & HasKey<K5>>>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Index<Index<A1>>>>, K6>) => KeyAt<Index<Unpack<Index<Index<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<Indexable>>>>, T4>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Index<Index<A1>>>>>) => Index<Index<Unpack<Index<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, T4, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Index<Index<A1>>>>>) => Unpack<Index<Unpack<Index<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Indexable>>>, T4, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Index<Index<A1>>>>, K6>) => KeyAt<Unpack<Unpack<Index<Index<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, T4, T5>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Index<Index<A1>>>>>) => Index<Unpack<Unpack<Index<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Index<Index<A1>>>>>) => Unpack<Unpack<Unpack<Index<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4 & Collection<T5>>>>, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable<Collection<T4>>>, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Indexable>, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, i3: number, l4: Lens<Index<Index<A1>>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>>) => Index<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Unpack<Index<A1>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, HasKey<K5>>>>, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Unpack<Index<A1>>, K4>>, K6>) => KeyAt<Index<KeyAt<Unpack<Index<A1>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, T3, K4 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Unpack<Index<A1>>, K4>>>) => Index<Index<KeyAt<Unpack<Index<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, T3, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Unpack<Index<A1>>, K4>>>) => Unpack<Index<KeyAt<Unpack<Index<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Indexable>>>, T3, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Unpack<Index<A1>>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Unpack<Index<A1>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Unpack<Index<A1>>, K4>>>) => Index<Unpack<KeyAt<Unpack<Index<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Unpack<Index<A1>>, K4>>>) => Unpack<Unpack<KeyAt<Unpack<Index<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4, Collection<T5>>>>, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & HasKey<K4>>>, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Unpack<Index<A1>>>, K5>, K6>) => KeyAt<KeyAt<Index<Unpack<Index<A1>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, T3, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Unpack<Index<A1>>>, K5>>) => Index<KeyAt<Index<Unpack<Index<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, T3, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Unpack<Index<A1>>>, K5>>) => Unpack<KeyAt<Index<Unpack<Index<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<HasKey<K5>>>>, T3, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, T3, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Unpack<Index<A1>>>>, K6>) => KeyAt<Index<Index<Unpack<Index<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<Indexable>>>>, T3>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Unpack<Index<A1>>>>>) => Index<Index<Index<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, T3, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Unpack<Index<A1>>>>>) => Unpack<Index<Index<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Indexable>>>, T3, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, T3, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Unpack<Index<A1>>>>, K6>) => KeyAt<Unpack<Index<Unpack<Index<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, T3, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Unpack<Index<A1>>>>>) => Index<Unpack<Index<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, T3, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Unpack<Index<A1>>>>>) => Unpack<Unpack<Index<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable<Collection<T5>>>>, T3, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Indexable>>, T3, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Unpack<Index<A1>>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Unpack<Index<A1>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Unpack<Index<A1>>>, K5>>) => Index<KeyAt<Unpack<Unpack<Index<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Unpack<Index<A1>>>, K5>>) => Unpack<KeyAt<Unpack<Unpack<Index<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & HasKey<K5>>>>, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, T3, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Unpack<Index<A1>>>>, K6>) => KeyAt<Index<Unpack<Unpack<Index<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, T3, T4>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Unpack<Index<A1>>>>>) => Index<Index<Unpack<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, T3, T4, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Unpack<Index<A1>>>>>) => Unpack<Index<Unpack<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Indexable>>>, T3, T4, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Unpack<Index<A1>>>>, K6>) => KeyAt<Unpack<Unpack<Unpack<Index<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, T3, T4, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Unpack<Index<A1>>>>>) => Index<Unpack<Unpack<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, T3, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Unpack<Index<A1>>>>>) => Unpack<Unpack<Unpack<Unpack<Index<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4 & Collection<T5>>>>, T3, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3 & Collection<T4>>>, T3, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable<Collection<T3>>, T3, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Indexable, A3, A4, A5, A6>(l1: Lens<S1, A1>, i2: number, l3: Lens<Index<A1>, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>>, T2, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>>) => Index<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>>) => Unpack<KeyAt<KeyAt<KeyAt<Unpack<A1>, K3>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, HasKey<K5>>>>, T2, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<T2, K3>, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>, K6>) => KeyAt<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Indexable>>>>, T2, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => Index<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>>, T2, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => Unpack<Index<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Indexable>>>, T2, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<T2, K3>, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>, K6>) => KeyAt<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>>, T2, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => Index<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => Unpack<Unpack<KeyAt<KeyAt<Unpack<A1>, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4, Collection<T5>>>>, T2, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, HasKey<K4>>>, T2, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<T2, K3>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>, K6>) => KeyAt<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Indexable>>>>, T2, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>>) => Index<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>>) => Unpack<KeyAt<Index<KeyAt<Unpack<A1>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<HasKey<K5>>>>, T2, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<T2, K3>>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<HasKey<K6>>>>>, T2, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<KeyAt<Unpack<A1>, K3>>>, K6>) => KeyAt<Index<Index<KeyAt<Unpack<A1>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<Indexable>>>>, T2, K3 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<KeyAt<Unpack<A1>, K3>>>>) => Index<Index<Index<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable<Collection<T6>>>>>, T2, K3 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<KeyAt<Unpack<A1>, K3>>>>) => Unpack<Index<Index<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Indexable>>>, T2, K3 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<T2, K3>>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<KeyAt<Unpack<A1>, K3>>>, K6>) => KeyAt<Unpack<Index<KeyAt<Unpack<A1>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Indexable>>>>, T2, K3 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<KeyAt<Unpack<A1>, K3>>>>) => Index<Unpack<Index<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<KeyAt<Unpack<A1>, K3>>>>) => Unpack<Unpack<Index<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable<Collection<T5>>>>, T2, K3 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Indexable>>, T2, K3 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<T2, K3>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>, K6>) => KeyAt<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>>, T2, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>>) => Index<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>>) => Unpack<KeyAt<Unpack<KeyAt<Unpack<A1>, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & HasKey<K5>>>>, T2, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>>, T2, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<KeyAt<Unpack<A1>, K3>>>, K6>) => KeyAt<Index<Unpack<KeyAt<Unpack<A1>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Indexable>>>>, T2, K3 extends string, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<KeyAt<Unpack<A1>, K3>>>>) => Index<Index<Unpack<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>>, T2, K3 extends string, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<KeyAt<Unpack<A1>, K3>>>>) => Unpack<Index<Unpack<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Indexable>>>, T2, K3 extends string, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>, K6>) => KeyAt<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>>, T2, K3 extends string, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>>) => Index<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>>) => Unpack<Unpack<Unpack<KeyAt<Unpack<A1>, K3>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4 & Collection<T5>>>>, T2, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3, Collection<T4>>>, T2, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & HasKey<K3>>, T2, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, k3: K3, l4: Lens<KeyAt<T2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Indexable>>>>, T2, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>>) => Index<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Index<Unpack<A1>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, HasKey<K5>>>>, T2, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<T2>, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<HasKey<K6>>>>>, T2, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Index<Unpack<A1>>, K4>>, K6>) => KeyAt<Index<KeyAt<Index<Unpack<A1>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<Indexable>>>>, T2, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Index<Unpack<A1>>, K4>>>) => Index<Index<KeyAt<Index<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable<Collection<T6>>>>>, T2, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Index<Unpack<A1>>, K4>>>) => Unpack<Index<KeyAt<Index<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Indexable>>>, T2, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<T2>, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Index<Unpack<A1>>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Index<Unpack<A1>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Indexable>>>>, T2, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Index<Unpack<A1>>, K4>>>) => Index<Unpack<KeyAt<Index<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Index<Unpack<A1>>, K4>>>) => Unpack<Unpack<KeyAt<Index<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4, Collection<T5>>>>, T2, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<HasKey<K4>>>, T2, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<T2>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, HasKey<K6>>>>>, T2, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Index<Unpack<A1>>>, K5>, K6>) => KeyAt<KeyAt<Index<Index<Unpack<A1>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, Indexable>>>>, T2, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Index<Unpack<A1>>>, K5>>) => Index<KeyAt<Index<Index<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5, Collection<T6>>>>>, T2, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Index<Unpack<A1>>>, K5>>) => Unpack<KeyAt<Index<Index<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<HasKey<K5>>>>, T2, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<T2>>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<HasKey<K6>>>>>, T2, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Index<Unpack<A1>>>>, K6>) => KeyAt<Index<Index<Index<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<Indexable>>>>, T2>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Index<Unpack<A1>>>>>) => Index<Index<Index<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable<Collection<T6>>>>>, T2, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Index<Unpack<A1>>>>>) => Unpack<Index<Index<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Indexable>>>, T2, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<T2>>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & HasKey<K6>>>>>, T2, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Index<Unpack<A1>>>>, K6>) => KeyAt<Unpack<Index<Index<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & Indexable>>>>, T2, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Index<Unpack<A1>>>>>) => Index<Unpack<Index<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5 & Collection<T6>>>>>, T2, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Index<Unpack<A1>>>>>) => Unpack<Unpack<Index<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable<Collection<T5>>>>, T2, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Indexable>>, T2, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, i4: number, l5: Lens<Index<Index<T2>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Index<Unpack<A1>>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Index<Unpack<A1>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Indexable>>>>, T2, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Index<Unpack<A1>>>, K5>>) => Index<KeyAt<Unpack<Index<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Index<Unpack<A1>>>, K5>>) => Unpack<KeyAt<Unpack<Index<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & HasKey<K5>>>>, T2, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<HasKey<K6>>>>>, T2, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Index<Unpack<A1>>>>, K6>) => KeyAt<Index<Unpack<Index<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<Indexable>>>>, T2, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Index<Unpack<A1>>>>>) => Index<Index<Unpack<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable<Collection<T6>>>>>, T2, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Index<Unpack<A1>>>>>) => Unpack<Index<Unpack<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Indexable>>>, T2, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Index<Unpack<A1>>>>, K6>) => KeyAt<Unpack<Unpack<Index<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Indexable>>>>, T2, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Index<Unpack<A1>>>>>) => Index<Unpack<Unpack<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Index<Unpack<A1>>>>>) => Unpack<Unpack<Unpack<Index<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4 & Collection<T5>>>>, T2, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable<Collection<T4>>>, T2, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Indexable>, T2, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, i3: number, l4: Lens<Index<T2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>>, T2, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>>, T2, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>>) => Index<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>>, T2, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Unpack<Unpack<A1>>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, HasKey<K5>>>>, T2, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>>, T2, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Unpack<Unpack<A1>>, K4>>, K6>) => KeyAt<Index<KeyAt<Unpack<Unpack<A1>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Indexable>>>>, T2, T3, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Unpack<Unpack<A1>>, K4>>>) => Index<Index<KeyAt<Unpack<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>>, T2, T3, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Unpack<Unpack<A1>>, K4>>>) => Unpack<Index<KeyAt<Unpack<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Indexable>>>, T2, T3, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>>, T2, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>>, T2, T3, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>>) => Index<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>>, T2, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>>) => Unpack<Unpack<KeyAt<Unpack<Unpack<A1>>, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4, Collection<T5>>>>, T2, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & HasKey<K4>>>, T2, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>>, T2, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Unpack<Unpack<A1>>>, K5>, K6>) => KeyAt<KeyAt<Index<Unpack<Unpack<A1>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Indexable>>>>, T2, T3, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Unpack<Unpack<A1>>>, K5>>) => Index<KeyAt<Index<Unpack<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>>, T2, T3, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Unpack<Unpack<A1>>>, K5>>) => Unpack<KeyAt<Index<Unpack<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<HasKey<K5>>>>, T2, T3, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<HasKey<K6>>>>>, T2, T3, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Unpack<Unpack<A1>>>>, K6>) => KeyAt<Index<Index<Unpack<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<Indexable>>>>, T2, T3>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Unpack<Unpack<A1>>>>>) => Index<Index<Index<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable<Collection<T6>>>>>, T2, T3, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Unpack<Unpack<A1>>>>>) => Unpack<Index<Index<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Indexable>>>, T2, T3, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>>, T2, T3, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Unpack<Unpack<A1>>>>, K6>) => KeyAt<Unpack<Index<Unpack<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Indexable>>>>, T2, T3, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Unpack<Unpack<A1>>>>>) => Index<Unpack<Index<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>>, T2, T3, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Unpack<Unpack<A1>>>>>) => Unpack<Unpack<Index<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable<Collection<T5>>>>, T2, T3, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Indexable>>, T2, T3, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>>, T2, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>>, T2, T3, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>>) => Index<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>>, T2, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>>) => Unpack<KeyAt<Unpack<Unpack<Unpack<A1>>>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & HasKey<K5>>>>, T2, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>>, T2, T3, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Unpack<Unpack<A1>>>>, K6>) => KeyAt<Index<Unpack<Unpack<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Indexable>>>>, T2, T3, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Unpack<Unpack<A1>>>>>) => Index<Index<Unpack<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>>, T2, T3, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Unpack<Unpack<A1>>>>>) => Unpack<Index<Unpack<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Indexable>>>, T2, T3, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>>, T2, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Unpack<Unpack<A1>>>>, K6>) => KeyAt<Unpack<Unpack<Unpack<Unpack<A1>>>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>>, T2, T3, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Unpack<Unpack<A1>>>>>) => Index<Unpack<Unpack<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>>, T2, T3, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Unpack<Unpack<A1>>>>>) => Unpack<Unpack<Unpack<Unpack<Unpack<A1>>>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4 & Collection<T5>>>>, T2, T3, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3 & Collection<T4>>>, T2, T3, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2 & Collection<T3>>, T2, T3, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1 extends Collection<T2>, T2, A3, A4, A5, A6>(l1: Lens<S1, A1>, t2: Traversal<T2>, l3: Lens<T2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, HasKey<K6>>>>, K3 extends string, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Indexable>>>, K3 extends string, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => Index<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5, Collection<T6>>>>, K3 extends string, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => Unpack<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, HasKey<K5>>>, K3 extends string, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<KeyAt<A2, K3>, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<HasKey<K6>>>>, K3 extends string, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => KeyAt<Index<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<Indexable>>>, K3 extends string, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => Index<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable<Collection<T6>>>>, K3 extends string, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => Unpack<Index<KeyAt<KeyAt<A2, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Indexable>>, K3 extends string, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, i5: number, l6: Lens<Index<KeyAt<KeyAt<A2, K3>, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & HasKey<K6>>>>, K3 extends string, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => KeyAt<Unpack<KeyAt<KeyAt<A2, K3>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Indexable>>>, K3 extends string, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => Index<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5 & Collection<T6>>>>, K3 extends string, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => Unpack<Unpack<KeyAt<KeyAt<A2, K3>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4, Collection<T5>>>, K3 extends string, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, HasKey<K4>>, K3 extends string, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, k4: K4, l5: Lens<KeyAt<KeyAt<A2, K3>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, HasKey<K6>>>>, K3 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => KeyAt<KeyAt<Index<KeyAt<A2, K3>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, Indexable>>>, K3 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => Index<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5, Collection<T6>>>>, K3 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => Unpack<KeyAt<Index<KeyAt<A2, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<HasKey<K5>>>, K3 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, k5: K5, l6: Lens<KeyAt<Index<KeyAt<A2, K3>>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<HasKey<K6>>>>, K3 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => KeyAt<Index<Index<KeyAt<A2, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<Indexable>>>, K3 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<KeyAt<A2, K3>>>>) => Index<Index<Index<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Indexable<Collection<T6>>>>, K3 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<KeyAt<A2, K3>>>>) => Unpack<Index<Index<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Indexable>>, K3 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, i5: number, l6: Lens<Index<Index<KeyAt<A2, K3>>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & HasKey<K6>>>>, K3 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => KeyAt<Unpack<Index<KeyAt<A2, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & Indexable>>>, K3 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<KeyAt<A2, K3>>>>) => Index<Unpack<Index<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5 & Collection<T6>>>>, K3 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => Unpack<Unpack<Index<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable<Collection<T5>>>, K3 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Indexable>, K3 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, i4: number, l5: Lens<Index<KeyAt<A2, K3>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, HasKey<K6>>>>, K3 extends string, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => KeyAt<KeyAt<Unpack<KeyAt<A2, K3>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Indexable>>>, K3 extends string, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => Index<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5, Collection<T6>>>>, K3 extends string, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => Unpack<KeyAt<Unpack<KeyAt<A2, K3>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & HasKey<K5>>>, K3 extends string, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<HasKey<K6>>>>, K3 extends string, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => KeyAt<Index<Unpack<KeyAt<A2, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<Indexable>>>, K3 extends string, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<KeyAt<A2, K3>>>>) => Index<Index<Unpack<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable<Collection<T6>>>>, K3 extends string, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => Unpack<Index<Unpack<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Indexable>>, K3 extends string, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & HasKey<K6>>>>, K3 extends string, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => KeyAt<Unpack<Unpack<KeyAt<A2, K3>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Indexable>>>, K3 extends string, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => Index<Unpack<Unpack<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5 & Collection<T6>>>>, K3 extends string, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => Unpack<Unpack<Unpack<KeyAt<A2, K3>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4 & Collection<T5>>>, K3 extends string, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3, Collection<T4>>, K3 extends string, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends HasKey<K3>, K3 extends string, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, k3: K3, l4: Lens<KeyAt<A2, K3>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, HasKey<K6>>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Index<A2>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, Indexable>>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => Index<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5, Collection<T6>>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Index<A2>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, HasKey<K5>>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<Index<A2>, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<HasKey<K6>>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => KeyAt<Index<KeyAt<Index<A2>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<Indexable>>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Index<A2>, K4>>>) => Index<Index<KeyAt<Index<A2>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Indexable<Collection<T6>>>>, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Index<A2>, K4>>>) => Unpack<Index<KeyAt<Index<A2>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Indexable>>, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, i5: number, l6: Lens<Index<KeyAt<Index<A2>, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & HasKey<K6>>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Index<A2>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & Indexable>>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Index<A2>, K4>>>) => Index<Unpack<KeyAt<Index<A2>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5 & Collection<T6>>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => Unpack<Unpack<KeyAt<Index<A2>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4, Collection<T5>>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<HasKey<K4>>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, k4: K4, l5: Lens<KeyAt<Index<A2>, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, HasKey<K6>>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => KeyAt<KeyAt<Index<Index<A2>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, Indexable>>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Index<A2>>, K5>>) => Index<KeyAt<Index<Index<A2>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<HasKey<K5, Collection<T6>>>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Index<A2>>, K5>>) => Unpack<KeyAt<Index<Index<A2>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<HasKey<K5>>>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, k5: K5, l6: Lens<KeyAt<Index<Index<A2>>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Indexable<HasKey<K6>>>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Index<A2>>>, K6>) => KeyAt<Index<Index<Index<A2>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Indexable<Indexable>>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Index<A2>>>>) => Index<Index<Index<Index<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Indexable<Collection<T6>>>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Index<A2>>>>) => Unpack<Index<Index<Index<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Indexable>>, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, i5: number, l6: Lens<Index<Index<Index<A2>>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & HasKey<K6>>>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Index<A2>>>, K6>) => KeyAt<Unpack<Index<Index<A2>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & Indexable>>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Index<A2>>>>) => Index<Unpack<Index<Index<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Collection<T5 & Collection<T6>>>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Index<A2>>>>) => Unpack<Unpack<Index<Index<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable<Collection<T5>>>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable>, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable>, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable>, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Indexable>, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, i4: number, l5: Lens<Index<Index<A2>>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, HasKey<K6>>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Index<A2>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, Indexable>>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Index<A2>>, K5>>) => Index<KeyAt<Unpack<Index<A2>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5, Collection<T6>>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => Unpack<KeyAt<Unpack<Index<A2>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & HasKey<K5>>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<HasKey<K6>>>>, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Index<A2>>>, K6>) => KeyAt<Index<Unpack<Index<A2>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<Indexable>>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Index<A2>>>>) => Index<Index<Unpack<Index<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Indexable<Collection<T6>>>>, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Index<A2>>>>) => Unpack<Index<Unpack<Index<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Indexable>>, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & HasKey<K6>>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => KeyAt<Unpack<Unpack<Index<A2>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & Indexable>>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Index<A2>>>>) => Index<Unpack<Unpack<Index<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5 & Collection<T6>>>>, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Index<A2>>>>) => Unpack<Unpack<Unpack<Index<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4 & Collection<T5>>>, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable<Collection<T4>>, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Indexable, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, i3: number, l4: Lens<Index<A2>, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, HasKey<K6>>>>, T3, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<Unpack<A2>, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Indexable>>>, T3, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => Index<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5, Collection<T6>>>>, T3, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => Unpack<KeyAt<KeyAt<Unpack<A2>, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, HasKey<K5>>>, T3, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<T3, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<HasKey<K6>>>>, T3, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => KeyAt<Index<KeyAt<Unpack<A2>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<Indexable>>>, T3, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<Unpack<A2>, K4>>>) => Index<Index<KeyAt<Unpack<A2>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable<Collection<T6>>>>, T3, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => Unpack<Index<KeyAt<Unpack<A2>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Indexable>>, T3, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<T3, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & HasKey<K6>>>>, T3, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => KeyAt<Unpack<KeyAt<Unpack<A2>, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Indexable>>>, T3, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => Index<Unpack<KeyAt<Unpack<A2>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5 & Collection<T6>>>>, T3, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => Unpack<Unpack<KeyAt<Unpack<A2>, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4, Collection<T5>>>, T3, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & HasKey<K4>>, T3, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, k4: K4, l5: Lens<KeyAt<T3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, HasKey<K6>>>>, T3, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => KeyAt<KeyAt<Index<Unpack<A2>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, Indexable>>>, T3, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<Unpack<A2>>, K5>>) => Index<KeyAt<Index<Unpack<A2>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5, Collection<T6>>>>, T3, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => Unpack<KeyAt<Index<Unpack<A2>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<HasKey<K5>>>, T3, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<T3>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<HasKey<K6>>>>, T3, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<Unpack<A2>>>, K6>) => KeyAt<Index<Index<Unpack<A2>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<Indexable>>>, T3>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<Unpack<A2>>>>) => Index<Index<Index<Unpack<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Indexable<Collection<T6>>>>, T3, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<Unpack<A2>>>>) => Unpack<Index<Index<Unpack<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Indexable>>, T3, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, i5: number, l6: Lens<Index<Index<T3>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & HasKey<K6>>>>, T3, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => KeyAt<Unpack<Index<Unpack<A2>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & Indexable>>>, T3, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<Unpack<A2>>>>) => Index<Unpack<Index<Unpack<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5 & Collection<T6>>>>, T3, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<Unpack<A2>>>>) => Unpack<Unpack<Index<Unpack<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable<Collection<T5>>>, T3, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Indexable>, T3, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, i4: number, l5: Lens<Index<T3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, HasKey<K6>>>>, T3, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => KeyAt<KeyAt<Unpack<Unpack<A2>>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Indexable>>>, T3, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => Index<KeyAt<Unpack<Unpack<A2>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5, Collection<T6>>>>, T3, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => Unpack<KeyAt<Unpack<Unpack<A2>>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & HasKey<K5>>>, T3, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<HasKey<K6>>>>, T3, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => KeyAt<Index<Unpack<Unpack<A2>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<Indexable>>>, T3, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<Unpack<A2>>>>) => Index<Index<Unpack<Unpack<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable<Collection<T6>>>>, T3, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<Unpack<A2>>>>) => Unpack<Index<Unpack<Unpack<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Indexable>>, T3, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & HasKey<K6>>>>, T3, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => KeyAt<Unpack<Unpack<Unpack<A2>>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Indexable>>>, T3, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<Unpack<A2>>>>) => Index<Unpack<Unpack<Unpack<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5 & Collection<T6>>>>, T3, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<Unpack<A2>>>>) => Unpack<Unpack<Unpack<Unpack<A2>>>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4 & Collection<T5>>>, T3, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3 & Collection<T4>>, T3, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2 extends Collection<T3>, T3, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, t3: Traversal<T3>, l4: Lens<T3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, HasKey<K6>>>, K4 extends string, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => KeyAt<KeyAt<KeyAt<A3, K4>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, Indexable>>, K4 extends string, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, i6: number): (f: (v: Index<KeyAt<KeyAt<A3, K4>, K5>>) => Index<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5, Collection<T6>>>, K4 extends string, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => Unpack<KeyAt<KeyAt<A3, K4>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, HasKey<K5>>, K4 extends string, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, k5: K5, l6: Lens<KeyAt<KeyAt<A3, K4>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Indexable<HasKey<K6>>>, K4 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, k6: K6): (f: (v: KeyAt<Index<KeyAt<A3, K4>>, K6>) => KeyAt<Index<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Indexable<Indexable>>, K4 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, i6: number): (f: (v: Index<Index<KeyAt<A3, K4>>>) => Index<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Indexable<Collection<T6>>>, K4 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<KeyAt<A3, K4>>>) => Unpack<Index<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Indexable>, K4 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, i5: number, l6: Lens<Index<KeyAt<A3, K4>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & HasKey<K6>>>, K4 extends string, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => KeyAt<Unpack<KeyAt<A3, K4>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & Indexable>>, K4 extends string, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<KeyAt<A3, K4>>>) => Index<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Collection<T5 & Collection<T6>>>, K4 extends string, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<KeyAt<A3, K4>>>) => Unpack<Unpack<KeyAt<A3, K4>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4, Collection<T5>>, K4 extends string, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends HasKey<K4>, K4 extends string, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, k4: K4, l5: Lens<KeyAt<A3, K4>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<HasKey<K5, HasKey<K6>>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Index<A3>, K5>, K6>) => KeyAt<KeyAt<Index<A3>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<HasKey<K5, Indexable>>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, i6: number): (f: (v: Index<KeyAt<Index<A3>, K5>>) => Index<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<HasKey<K5, Collection<T6>>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Index<A3>, K5>>) => Unpack<KeyAt<Index<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<HasKey<K5>>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, k5: K5, l6: Lens<KeyAt<Index<A3>, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Indexable<HasKey<K6>>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, k6: K6): (f: (v: KeyAt<Index<Index<A3>>, K6>) => KeyAt<Index<Index<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Indexable<Indexable>>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, i6: number): (f: (v: Index<Index<Index<A3>>>) => Index<Index<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Indexable<Collection<T6>>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Index<A3>>>) => Unpack<Index<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Indexable>, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, i5: number, l6: Lens<Index<Index<A3>>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Collection<T5 & HasKey<K6>>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Index<A3>>, K6>) => KeyAt<Unpack<Index<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Collection<T5 & Indexable>>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Index<A3>>>) => Index<Unpack<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Collection<T5 & Collection<T6>>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Index<A3>>>) => Unpack<Unpack<Index<A3>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable<Collection<T5>>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Indexable, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, i4: number, l5: Lens<Index<A3>, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, HasKey<K6>>>, T4, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => KeyAt<KeyAt<Unpack<A3>, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, Indexable>>, T4, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, i6: number): (f: (v: Index<KeyAt<Unpack<A3>, K5>>) => Index<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5, Collection<T6>>>, T4, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<Unpack<A3>, K5>>) => Unpack<KeyAt<Unpack<A3>, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & HasKey<K5>>, T4, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, k5: K5, l6: Lens<KeyAt<T4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Indexable<HasKey<K6>>>, T4, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, k6: K6): (f: (v: KeyAt<Index<Unpack<A3>>, K6>) => KeyAt<Index<Unpack<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Indexable<Indexable>>, T4>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, i6: number): (f: (v: Index<Index<Unpack<A3>>>) => Index<Index<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Indexable<Collection<T6>>>, T4, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<Unpack<A3>>>) => Unpack<Index<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Indexable>, T4, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, i5: number, l6: Lens<Index<T4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & HasKey<K6>>>, T4, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<Unpack<A3>>, K6>) => KeyAt<Unpack<Unpack<A3>>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & Indexable>>, T4, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<Unpack<A3>>>) => Index<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Collection<T5 & Collection<T6>>>, T4, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<Unpack<A3>>>) => Unpack<Unpack<Unpack<A3>>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4 & Collection<T5>>, T4, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4>, T4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3 extends Collection<T4>, T4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, t4: Traversal<T4>, l5: Lens<T4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends HasKey<K5, HasKey<K6>>, K5 extends string, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, k6: K6): (f: (v: KeyAt<KeyAt<A4, K5>, K6>) => KeyAt<KeyAt<A4, K5>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends HasKey<K5, Indexable>, K5 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, i6: number): (f: (v: Index<KeyAt<A4, K5>>) => Index<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends HasKey<K5, Collection<T6>>, K5 extends string, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, t6: Traversal<T6>): (f: (v: Unpack<KeyAt<A4, K5>>) => Unpack<KeyAt<A4, K5>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends HasKey<K5>, K5 extends string, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, k5: K5, l6: Lens<KeyAt<A4, K5>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Indexable<HasKey<K6>>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, k6: K6): (f: (v: KeyAt<Index<A4>, K6>) => KeyAt<Index<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Indexable<Indexable>>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, i6: number): (f: (v: Index<Index<A4>>) => Index<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Indexable<Collection<T6>>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, t6: Traversal<T6>): (f: (v: Unpack<Index<A4>>) => Unpack<Index<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Indexable, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, i5: number, l6: Lens<Index<A4>, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Collection<T5 & HasKey<K6>>, T5, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, k6: K6): (f: (v: KeyAt<Unpack<A4>, K6>) => KeyAt<Unpack<A4>, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Collection<T5 & Indexable>, T5>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, i6: number): (f: (v: Index<Unpack<A4>>) => Index<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Collection<T5 & Collection<T6>>, T5, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, t6: Traversal<T6>): (f: (v: Unpack<Unpack<A4>>) => Unpack<Unpack<A4>>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4 extends Collection<T5>, T5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, t5: Traversal<T5>, l6: Lens<T5, A6>): (f: (v: A6) => A6) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4, A5 extends HasKey<K6>, K6 extends string>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, k6: K6): (f: (v: KeyAt<A5, K6>) => KeyAt<A5, K6>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4, A5 extends Indexable>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, i6: number): (f: (v: Index<A5>) => Index<A5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4, A5 extends Collection<T6>, T6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, t6: Traversal<T6>): (f: (v: Unpack<A5>) => Unpack<A5>) => (s: S1) => S1

export function mod<S1, A1, A2, A3, A4, A5, A6>(l1: Lens<S1, A1>, l2: Lens<A1, A2>, l3: Lens<A2, A3>, l4: Lens<A3, A4>, l5: Lens<A4, A5>, l6: Lens<A5, A6>): (f: (v: A6) => A6) => (s: S1) => S1