export declare class At<S, I, A> {
  constructor(readonly at: (i: I) => Lens<S, A>)
}

fromIso<T>(iso: Iso<T, S>): At<T, I, A>

readonly _tag: "At"

export declare class Fold<S, A> {
  constructor(readonly foldMap: <M>(M: Monoid<M>) => (f: (a: A) => M) => (s: S) => M)
}

compose<B>(ab: Fold<A, B>): Fold<S, B>

composeFold<B>(ab: Fold<A, B>): Fold<S, B>

composeGetter<B>(ab: Getter<A, B>): Fold<S, B>

composeTraversal<B>(ab: Traversal<A, B>): Fold<S, B>

composeOptional<B>(ab: Optional<A, B>): Fold<S, B>

composeLens<B>(ab: Lens<A, B>): Fold<S, B>

composePrism<B>(ab: Prism<A, B>): Fold<S, B>

composeIso<B>(ab: Iso<A, B>): Fold<S, B>

find<B extends A>(p: Refinement<A, B>): (s: S) => Option<B>
find(p: Predicate<A>): (s: S) => Option<A>

headOption(s: S): Option<A>

readonly _tag: "Fold"

readonly getAll: (s: S) => Array<A>

readonly exist: (p: Predicate<A>) => Predicate<S>

readonly all: (p: Predicate<A>) => Predicate<S>

export declare class Getter<S, A> {
  constructor(readonly get: (s: S) => A)
}

asFold(): Fold<S, A>

compose<B>(ab: Getter<A, B>): Getter<S, B>

composeGetter<B>(ab: Getter<A, B>): Getter<S, B>

composeFold<B>(ab: Fold<A, B>): Fold<S, B>

composeLens<B>(ab: Lens<A, B>): Getter<S, B>

composeIso<B>(ab: Iso<A, B>): Getter<S, B>

composeTraversal<B>(ab: Traversal<A, B>): Fold<S, B>

composeOptional<B>(ab: Optional<A, B>): Fold<S, B>

composePrism<B>(ab: Prism<A, B>): Fold<S, B>

readonly _tag: "Getter"

export declare class Index<S, I, A> {
  constructor(readonly index: (i: I) => Optional<S, A>)
}

static fromAt<T, J, B>(at: At<T, J, Option<B>>): Index<T, J, B>

fromIso<T>(iso: Iso<T, S>): Index<T, I, A>

readonly _tag: "Index"

export declare class Iso<S, A> {
  constructor(readonly get: (s: S) => A, readonly reverseGet: (a: A) => S)
}

reverse(): Iso<A, S>

modify(f: (a: A) => A): (s: S) => S

asLens(): Lens<S, A>

asPrism(): Prism<S, A>

asOptional(): Optional<S, A>

asTraversal(): Traversal<S, A>

asFold(): Fold<S, A>

asGetter(): Getter<S, A>

asSetter(): Setter<S, A>

compose<B>(ab: Iso<A, B>): Iso<S, B>

composeIso<B>(ab: Iso<A, B>): Iso<S, B>

composeLens<B>(ab: Lens<A, B>): Lens<S, B>

composePrism<B>(ab: Prism<A, B>): Prism<S, B>

composeOptional<B>(ab: Optional<A, B>): Optional<S, B>

composeTraversal<B>(ab: Traversal<A, B>): Traversal<S, B>

composeFold<B>(ab: Fold<A, B>): Fold<S, B>

composeGetter<B>(ab: Getter<A, B>): Getter<S, B>

composeSetter<B>(ab: Setter<A, B>): Setter<S, B>

readonly _tag: "Iso"

readonly unwrap: (s: S) => A

readonly to: (s: S) => A

readonly wrap: (a: A) => S

readonly from: (a: A) => S

export declare class Lens<S, A> {
  constructor(readonly get: (s: S) => A, readonly set: (a: A) => (s: S) => S)
}

static fromPath<S>(): LensFromPath<S>

import { Lens } from 'monocle-ts'

type Person = {
  name: string
  age: number
  address: {
    city: string
  }
}

const city = Lens.fromPath<Person>()(['address', 'city'])

const person: Person = { name: 'Giulio', age: 43, address: { city: 'Milan' } }

assert.strictEqual(city.get(person), 'Milan')
assert.deepStrictEqual(city.set('London')(person), { name: 'Giulio', age: 43, address: { city: 'London' } })

static fromProp<S>(): <P extends keyof S>(prop: P) => Lens<S, S[P]>

import { Lens } from 'monocle-ts'

type Person = {
  name: string
  age: number
}

const age = Lens.fromProp<Person>()('age')

const person: Person = { name: 'Giulio', age: 43 }

assert.strictEqual(age.get(person), 43)
assert.deepStrictEqual(age.set(44)(person), { name: 'Giulio', age: 44 })

static fromProps<S>(): <P extends keyof S>(props: Array<P>) => Lens<S, { [K in P]: S[K] }>

import { Lens } from 'monocle-ts'

interface Person {
  name: string
  age: number
  rememberMe: boolean
}

const lens = Lens.fromProps<Person>()(['name', 'age'])

const person: Person = { name: 'Giulio', age: 44, rememberMe: true }

assert.deepStrictEqual(lens.get(person), { name: 'Giulio', age: 44 })
assert.deepStrictEqual(lens.set({ name: 'Guido', age: 47 })(person), { name: 'Guido', age: 47, rememberMe: true })

static fromNullableProp<S>(): <A extends S[K], K extends keyof S>(
    k: K,
    defaultValue: A
  ) => Lens<S, NonNullable<S[K]>>

import { Lens } from 'monocle-ts'

interface Outer {
  inner?: Inner
}

interface Inner {
  value: number
  foo: string
}

const inner = Lens.fromNullableProp<Outer>()('inner', { value: 0, foo: 'foo' })
const value = Lens.fromProp<Inner>()('value')
const lens = inner.compose(value)

assert.deepStrictEqual(lens.set(1)({}), { inner: { value: 1, foo: 'foo' } })
assert.strictEqual(lens.get({}), 0)
assert.deepStrictEqual(lens.set(1)({ inner: { value: 1, foo: 'bar' } }), { inner: { value: 1, foo: 'bar' } })
assert.strictEqual(lens.get({ inner: { value: 1, foo: 'bar' } }), 1)

modify(f: (a: A) => A): (s: S) => S

asOptional(): Optional<S, A>

asTraversal(): Traversal<S, A>

asSetter(): Setter<S, A>

asGetter(): Getter<S, A>

asFold(): Fold<S, A>

compose<B>(ab: Lens<A, B>): Lens<S, B>

composeLens<B>(ab: Lens<A, B>): Lens<S, B>

composeGetter<B>(ab: Getter<A, B>): Getter<S, B>

composeFold<B>(ab: Fold<A, B>): Fold<S, B>

composeOptional<B>(ab: Optional<A, B>): Optional<S, B>

composeTraversal<B>(ab: Traversal<A, B>): Traversal<S, B>

composeSetter<B>(ab: Setter<A, B>): Setter<S, B>

composeIso<B>(ab: Iso<A, B>): Lens<S, B>

composePrism<B>(ab: Prism<A, B>): Optional<S, B>

readonly _tag: "Lens"

export declare class Optional<S, A> {
  constructor(readonly getOption: (s: S) => Option<A>, readonly set: (a: A) => (s: S) => S)
}

static fromPath<S>(): OptionalFromPath<S>

import { Optional } from 'monocle-ts'

interface Phone {
  number: string
}
interface Employment {
  phone?: Phone
}
interface Info {
  employment?: Employment
}
interface Response {
  info?: Info
}

const numberFromResponse = Optional.fromPath<Response>()(['info', 'employment', 'phone', 'number'])

const response1: Response = {
  info: {
    employment: {
      phone: {
        number: '555-1234',
      },
    },
  },
}
const response2: Response = {
  info: {
    employment: {},
  },
}

numberFromResponse.getOption(response1) // some('555-1234')
numberFromResponse.getOption(response2) // none

static fromNullableProp<S>(): <K extends keyof S>(k: K) => Optional<S, NonNullable<S[K]>>

import { Optional } from 'monocle-ts'

interface S {
  a: number | undefined | null
}

const optional = Optional.fromNullableProp<S>()('a')

const s1: S = { a: undefined }
const s2: S = { a: null }
const s3: S = { a: 1 }

assert.deepStrictEqual(optional.set(2)(s1), s1)
assert.deepStrictEqual(optional.set(2)(s2), s2)
assert.deepStrictEqual(optional.set(2)(s3), { a: 2 })

static fromOptionProp<S>(): <P extends OptionPropertyNames<S>>(prop: P) => Optional<S, OptionPropertyType<S, P>>

import { Optional } from 'monocle-ts'
import * as O from 'fp-ts/Option'

interface S {
  a: O.Option<number>
}

const optional = Optional.fromOptionProp<S>()('a')
const s1: S = { a: O.none }
const s2: S = { a: O.some(1) }
assert.deepStrictEqual(optional.set(2)(s1), s1)
assert.deepStrictEqual(optional.set(2)(s2), { a: O.some(2) })

modify(f: (a: A) => A): (s: S) => S

modifyOption(f: (a: A) => A): (s: S) => Option<S>

asTraversal(): Traversal<S, A>

asFold(): Fold<S, A>

asSetter(): Setter<S, A>

compose<B>(ab: Optional<A, B>): Optional<S, B>

composeOptional<B>(ab: Optional<A, B>): Optional<S, B>

composeTraversal<B>(ab: Traversal<A, B>): Traversal<S, B>

composeFold<B>(ab: Fold<A, B>): Fold<S, B>

composeSetter<B>(ab: Setter<A, B>): Setter<S, B>

composeLens<B>(ab: Lens<A, B>): Optional<S, B>

composePrism<B>(ab: Prism<A, B>): Optional<S, B>

composeIso<B>(ab: Iso<A, B>): Optional<S, B>

composeGetter<B>(ab: Getter<A, B>): Fold<S, B>

readonly _tag: "Optional"

export declare class Prism<S, A> {
  constructor(readonly getOption: (s: S) => Option<A>, readonly reverseGet: (a: A) => S)
}

static fromPredicate<S, A extends S>(refinement: Refinement<S, A>): Prism<S, A>
static fromPredicate<A>(predicate: Predicate<A>): Prism<A, A>

static some<A>(): Prism<Option<A>, A>

modify(f: (a: A) => A): (s: S) => S

modifyOption(f: (a: A) => A): (s: S) => Option<S>

set(a: A): (s: S) => S

asOptional(): Optional<S, A>

asTraversal(): Traversal<S, A>

asSetter(): Setter<S, A>

asFold(): Fold<S, A>

compose<B>(ab: Prism<A, B>): Prism<S, B>

composePrism<B>(ab: Prism<A, B>): Prism<S, B>

composeOptional<B>(ab: Optional<A, B>): Optional<S, B>

composeTraversal<B>(ab: Traversal<A, B>): Traversal<S, B>

composeFold<B>(ab: Fold<A, B>): Fold<S, B>

composeSetter<B>(ab: Setter<A, B>): Setter<S, B>

composeIso<B>(ab: Iso<A, B>): Prism<S, B>

composeLens<B>(ab: Lens<A, B>): Optional<S, B>

composeGetter<B>(ab: Getter<A, B>): Fold<S, B>

readonly _tag: "Prism"

export declare class Setter<S, A> {
  constructor(readonly modify: (f: (a: A) => A) => (s: S) => S)
}

set(a: A): (s: S) => S

compose<B>(ab: Setter<A, B>): Setter<S, B>

composeSetter<B>(ab: Setter<A, B>): Setter<S, B>

composeTraversal<B>(ab: Traversal<A, B>): Setter<S, B>

composeOptional<B>(ab: Optional<A, B>): Setter<S, B>

composeLens<B>(ab: Lens<A, B>): Setter<S, B>

composePrism<B>(ab: Prism<A, B>): Setter<S, B>

composeIso<B>(ab: Iso<A, B>): Setter<S, B>

readonly _tag: "Setter"

export declare class Traversal<S, A> {
  constructor(
    // Van Laarhoven representation
    readonly modifyF: ModifyF<S, A>
  )
}

modify(f: (a: A) => A): (s: S) => S

set(a: A): (s: S) => S

filter<B extends A>(refinement: Refinement<A, B>): Traversal<S, B>
filter(predicate: Predicate<A>): Traversal<S, A>

import { fromTraversable, Lens } from 'monocle-ts'
import { Traversable } from 'fp-ts/Array'

interface Person {
  name: string
  cool: boolean
}

const peopleTraversal = fromTraversable(Traversable)<Person>()
const coolLens = Lens.fromProp<Person>()('cool')
const people = [
  { name: 'bill', cool: false },
  { name: 'jill', cool: true },
]

const actual = peopleTraversal
  .filter((p) => p.name === 'bill')
  .composeLens(coolLens)
  .set(true)(people)

assert.deepStrictEqual(actual, [
  { name: 'bill', cool: true },
  { name: 'jill', cool: true },
])

asFold(): Fold<S, A>

asSetter(): Setter<S, A>

compose<B>(ab: Traversal<A, B>): Traversal<S, B>

composeTraversal<B>(ab: Traversal<A, B>): Traversal<S, B>

composeFold<B>(ab: Fold<A, B>): Fold<S, B>

composeSetter<B>(ab: Setter<A, B>): Setter<S, B>

composeOptional<B>(ab: Optional<A, B>): Traversal<S, B>

composeLens<B>(ab: Lens<A, B>): Traversal<S, B>

composePrism<B>(ab: Prism<A, B>): Traversal<S, B>

composeIso<B>(ab: Iso<A, B>): Traversal<S, B>

composeGetter<B>(ab: Getter<A, B>): Fold<S, B>

readonly _tag: "Traversal"

export declare function fromFoldable<F extends URIS3>(F: Foldable3<F>): <U, L, A>() => Fold<Kind3<F, U, L, A>, A>
export declare function fromFoldable<F extends URIS2>(F: Foldable2<F>): <L, A>() => Fold<Kind2<F, L, A>, A>
export declare function fromFoldable<F extends URIS>(F: Foldable1<F>): <A>() => Fold<Kind<F, A>, A>
export declare function fromFoldable<F>(F: Foldable<F>): <A>() => Fold<HKT<F, A>, A>

export declare function fromTraversable<T extends URIS3>(
  T: Traversable3<T>
): <U, L, A>() => Traversal<Kind3<T, U, L, A>, A>
export declare function fromTraversable<T extends URIS2>(T: Traversable2<T>): <L, A>() => Traversal<Kind2<T, L, A>, A>
export declare function fromTraversable<T extends URIS>(T: Traversable1<T>): <A>() => Traversal<Kind<T, A>, A>
export declare function fromTraversable<T>(T: Traversable<T>): <A>() => Traversal<HKT<T, A>, A>

import { Lens, fromTraversable } from 'monocle-ts'
import { Traversable } from 'fp-ts/Array'

interface Tweet {
  text: string
}

interface Tweets {
  tweets: Tweet[]
}

const tweetsLens = Lens.fromProp<Tweets>()('tweets')
const tweetTextLens = Lens.fromProp<Tweet>()('text')
const tweetTraversal = fromTraversable(Traversable)<Tweet>()
const composedTraversal = tweetsLens.composeTraversal(tweetTraversal).composeLens(tweetTextLens)

const tweet1: Tweet = { text: 'hello world' }
const tweet2: Tweet = { text: 'foobar' }
const model: Tweets = { tweets: [tweet1, tweet2] }

const actual = composedTraversal.modify((text) => text.split('').reverse().join(''))(model)

assert.deepStrictEqual(actual, { tweets: [{ text: 'dlrow olleh' }, { text: 'raboof' }] })

export interface LensFromPath<S> {
  <
    K1 extends keyof S,
    K2 extends keyof S[K1],
    K3 extends keyof S[K1][K2],
    K4 extends keyof S[K1][K2][K3],
    K5 extends keyof S[K1][K2][K3][K4]
  >(
    path: [K1, K2, K3, K4, K5]
  ): Lens<S, S[K1][K2][K3][K4][K5]>
  <K1 extends keyof S, K2 extends keyof S[K1], K3 extends keyof S[K1][K2], K4 extends keyof S[K1][K2][K3]>(
    path: [K1, K2, K3, K4]
  ): Lens<S, S[K1][K2][K3][K4]>
  <K1 extends keyof S, K2 extends keyof S[K1], K3 extends keyof S[K1][K2]>(path: [K1, K2, K3]): Lens<S, S[K1][K2][K3]>
  <K1 extends keyof S, K2 extends keyof S[K1]>(path: [K1, K2]): Lens<S, S[K1][K2]>
  <K1 extends keyof S>(path: [K1]): Lens<S, S[K1]>
}

export type ModifyF<S, A> = traversal.ModifyF<S, A>

export interface OptionalFromPath<S> {
  <
    K1 extends keyof S,
    K2 extends keyof NonNullable<S[K1]>,
    K3 extends keyof NonNullable<NonNullable<S[K1]>[K2]>,
    K4 extends keyof NonNullable<NonNullable<NonNullable<S[K1]>[K2]>[K3]>,
    K5 extends keyof NonNullable<NonNullable<NonNullable<NonNullable<S[K1]>[K2]>[K3]>[K4]>
  >(
    path: [K1, K2, K3, K4, K5]
  ): Optional<S, NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<S[K1]>[K2]>[K3]>[K4]>[K5]>>

  <
    K1 extends keyof S,
    K2 extends keyof NonNullable<S[K1]>,
    K3 extends keyof NonNullable<NonNullable<S[K1]>[K2]>,
    K4 extends keyof NonNullable<NonNullable<NonNullable<S[K1]>[K2]>[K3]>
  >(
    path: [K1, K2, K3, K4]
  ): Optional<S, NonNullable<NonNullable<NonNullable<NonNullable<S[K1]>[K2]>[K3]>[K4]>>

  <K1 extends keyof S, K2 extends keyof NonNullable<S[K1]>, K3 extends keyof NonNullable<NonNullable<S[K1]>[K2]>>(
    path: [K1, K2, K3]
  ): Optional<S, NonNullable<NonNullable<NonNullable<S[K1]>[K2]>[K3]>>

  <K1 extends keyof S, K2 extends keyof NonNullable<S[K1]>>(path: [K1, K2]): Optional<
    S,
    NonNullable<NonNullable<S[K1]>[K2]>
  >

  <K1 extends keyof S>(path: [K1]): Optional<S, NonNullable<S[K1]>>
}

export declare const at: typeof at

export declare const index: typeof index

export declare const iso: typeof iso

export declare const lens: typeof lens

export declare const optional: typeof optional

export declare const prism: typeof prism

export declare const traversal: typeof traversal