export declare const cons: {
  <A>(): Prism<readonly A[], readonly [A, readonly A[]]>
  <A, B>(): PolyPrism<readonly A[], readonly B[], readonly [A, readonly A[]], readonly [B, readonly B[]]>
}

export declare const findFirst: {
  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>, message?: string): Optional<readonly C[], B>
  <B extends A, A = B>(predicate: Predicate<A>, message?: string): Optional<readonly B[], B>
}

export declare const head: <A>() => Optional<readonly A[], A>

export declare const id: { <S>(): Iso<S, S>; <S, T>(): PolyIso<S, T, S, T> }

export declare const indexes: <A>() => Traversal<readonly A[], A>

export declare const iso: {
  <S, A>(get: (s: S) => A, encode: (a: A) => S): Iso<S, A>
  <S, T, A, B>(get: (s: S) => A, encode: (b: B) => T): PolyIso<S, T, A, B>
}

export declare const lens: {
  <S, A>(get: (s: S) => A, set: (a: A) => (s: S) => S): Lens<S, A>
  <S, T, A, B>(get: (s: S) => A, set: (b: B) => (s: S) => T): PolyLens<S, T, A, B>
}

export declare const optional: <S, A>(
  decode: (s: S) => Either.Either<A, Error>,
  replaceEither: (a: A) => (s: S) => Either.Either<S, Error>
) => Optional<S, A>

export declare const polyOptional: <S, T, A, B>(
  polyDecode: (s: S) => Either.Either<A, readonly [Error, T]>,
  polyReplaceEither: (b: B) => (s: S) => Either.Either<T, readonly [Error, T]>
) => PolyOptional<S, T, A, B>

export declare const polyPrism: <S, T, A, B>(
  polyDecode: (s: S) => Either.Either<A, readonly [Error, T]>,
  encode: (b: B) => T
) => PolyPrism<S, T, A, B>

export declare const polyTraversal: <S, T, A, B>(
  decode: (s: S) => Either.Either<readonly A[], readonly [Error, T]>,
  replace: (bs: readonly B[]) => (s: S) => Either.Either<T, readonly [Error, T]>
) => PolyTraversal<S, T, A, B>

export declare const prism: <S, A>(decode: (s: S) => Either.Either<A, Error>, encode: (a: A) => S) => Prism<S, A>

export declare const reversedFilter: {
  <A, S extends A>(refinement: Refinement<A, S>, message?: string): ReversedPrism<S, A>
  <S>(predicate: Predicate<S>, message?: string): ReversedPrism<S, S>
}

export declare const tail: <A>() => Optional<readonly A[], readonly A[]>

export declare const traversal: <S, A>(
  decode: (s: S) => Either.Either<readonly A[], Error>,
  replace: (as: readonly A[]) => (s: S) => Either.Either<S, Error>
) => Traversal<S, A>

export interface Fold<in S, out A> extends Getter<S, ReadonlyArray<A>> {}

export interface Getter<in S, out A> extends Optic<S, never, never, Error, unknown, A, unknown> {}

export interface Iso<in out S, in out A> extends PolyIso<S, S, A, A> {}

export interface Lens<in out S, in out A> extends PolyLens<S, S, A, A> {}

export interface Optic<
  in GetWhole,
  in SetWholeBefore,
  in SetPiece,
  out GetError,
  out SetError,
  out GetPiece,
  out SetWholeAfter
> {
  readonly getOptic: (GetWhole: GetWhole) => Either.Either<GetPiece, readonly [GetError, SetWholeAfter]>
  readonly setOptic: (
    SetPiece: SetPiece
  ) => (SetWholeBefore: SetWholeBefore) => Either.Either<SetWholeAfter, readonly [SetError, SetWholeAfter]>

  /**
   * @since 1.0.0
   */
  compose<S, A, B>(this: Iso<S, A>, that: Iso<A, B>): Iso<S, B>
  compose<S, T, A, B, C, D>(this: PolyIso<S, T, A, B>, that: PolyIso<A, B, C, D>): PolyIso<S, T, C, D>
  compose<S, A, B>(this: Lens<S, A>, that: Lens<A, B>): Lens<S, B>
  compose<S, T, A, B, C, D>(this: PolyLens<S, T, A, B>, that: PolyLens<A, B, C, D>): PolyLens<S, T, C, D>
  compose<S, A, B>(this: ReversedPrism<S, A>, that: ReversedPrism<A, B>): ReversedPrism<S, B>
  compose<S, T, A, B, C, D>(
    this: PolyReversedPrism<S, T, A, B>,
    that: PolyReversedPrism<A, B, C, D>
  ): PolyReversedPrism<S, T, C, D>
  compose<S, A, B>(this: Prism<S, A>, that: Prism<A, B>): Prism<S, B>
  compose<S, T, A, B, C, D>(this: PolyPrism<S, T, A, B>, that: PolyPrism<A, B, C, D>): PolyPrism<S, T, C, D>
  compose<S, A, B>(this: Optional<S, A>, that: Optional<A, B>): Optional<S, B>
  compose<S, T, A, B, C, D>(this: PolyOptional<S, T, A, B>, that: PolyOptional<A, B, C, D>): PolyOptional<S, T, C, D>

  /**
   * An optic that accesses the specified key of a struct or a tuple.
   *
   * @since 1.0.0
   */
  at<S, A, Key extends keyof A>(this: Lens<S, A>, key: Key): Lens<S, A[Key]>
  at<S, T, A, B, Key extends keyof A & keyof B>(this: PolyLens<S, T, A, B>, key: Key): PolyLens<S, T, A[Key], B[Key]>
  at<S, A, Key extends keyof A>(this: Optional<S, A>, key: Key): Optional<S, A[Key]>
  at<S, T, A, B, Key extends keyof A & keyof B>(
    this: PolyOptional<S, T, A, B>,
    key: Key
  ): PolyOptional<S, T, A[Key], B[Key]>

  /**
   * An optic that accesses a group of keys of a struct.
   *
   * @since 1.0.0
   */
  pick<S, A, Keys extends readonly [keyof A, ...Array<keyof A>]>(
    this: Lens<S, A>,
    ...keys: Keys
  ): Lens<S, { readonly [K in Keys[number]]: A[K] }>
  pick<S, A, Keys extends readonly [keyof A, ...Array<keyof A>]>(
    this: Optional<S, A>,
    ...keys: Keys
  ): Optional<S, { readonly [K in Keys[number]]: A[K] }>

  /**
   * An optic that excludes a group of keys of a struct.
   *
   * @since 1.0.0
   */
  omit<S, A, Keys extends readonly [keyof A, ...Array<keyof A>]>(
    this: Lens<S, A>,
    ...keys: Keys
  ): Lens<S, { readonly [K in Exclude<keyof A, Keys[number]>]: A[K] }>
  omit<S, A, Keys extends readonly [keyof A, ...Array<keyof A>]>(
    this: Optional<S, A>,
    ...keys: Keys
  ): Optional<S, { readonly [K in Exclude<keyof A, Keys[number]>]: A[K] }>

  /**
   * An optic that accesses the case specified by a predicate.
   *
   * @since 1.0.0
   */
  filter<S, A extends B, C extends B, B = A>(
    this: Prism<S, A>,
    refinement: Refinement<B, C>,
    message?: string
  ): Prism<S, C>
  filter<S, A extends B, B = A>(this: Prism<S, A>, predicate: Predicate<B>, message?: string): Prism<S, A>
  filter<S, A extends B, C extends B, B = A>(
    this: Optional<S, A>,
    refinement: Refinement<B, C>,
    message?: string
  ): Optional<S, C>
  filter<S, A extends B, B = A>(this: Optional<S, A>, predicate: Predicate<B>, message?: string): Optional<S, A>

  /**
   * An optic that accesses the `NonNullable` case of a nullable type.
   *
   * @since 1.0.0
   */
  nonNullable<S, A>(this: Prism<S, A>): Prism<S, NonNullable<A>>
  nonNullable<S, A>(this: Optional<S, A>): Optional<S, NonNullable<A>>

  /**
   * An optic that accesses the `Some` case of an `Option`.
   *
   * @since 1.0.0
   */
  some<S, A>(this: Prism<S, Option.Option<A>>): Prism<S, A>
  some<S, A>(this: Optional<S, Option.Option<A>>): Optional<S, A>

  /**
   * An optic that accesses the specified index of a `ReadonlyArray`.
   *
   * @since 1.0.0
   */
  index<S, A>(this: Optional<S, ReadonlyArray<A>>, n: number): Optional<S, A>

  /**
   * An optic that accesses the specified key of a record.
   *
   * @since 1.0.0
   */
  key<S, A>(this: Optional<S, Record.ReadonlyRecord<string, A>>, key: string): Optional<S, A>
}

export interface Optional<in out S, in out A> extends PolyOptional<S, S, A, A> {}

export interface PolyIso<in S, out T, out A, in B> extends Optic<S, unknown, B, never, never, A, T> {}

export interface PolyLens<in S, out T, out A, in B> extends Optic<S, S, B, never, never, A, T> {}

export interface PolyOptional<in S, out T, out A, in B> extends Optic<S, S, B, Error, Error, A, T> {}

export interface PolyPrism<in S, out T, out A, in B> extends Optic<S, unknown, B, Error, never, A, T> {}

export interface PolyReversedPrism<in S, out T, out A, in B> extends Optic<S, S, B, never, Error, A, T> {}

export interface PolySetter<in S, out T, in A> extends Optic<never, S, A, unknown, Error, unknown, T> {}

export interface PolyTraversal<in S, out T, out A, in B>
  extends PolyOptional<S, T, ReadonlyArray<A>, ReadonlyArray<B>> {}

export interface Prism<in out S, in out A> extends PolyPrism<S, S, A, A> {}

export interface ReversedPrism<in out S, in out A> extends PolyReversedPrism<S, S, A, A> {}

export interface Setter<in out S, in A> extends PolySetter<S, S, A> {}

export interface Traversal<in out S, in out A> extends PolyTraversal<S, S, A, A> {}

export declare const decode: <S, T, A, B>(optic: PolyPrism<S, T, A, B>) => (GetWhole: S) => Either.Either<A, Error>

export declare const encode: <S, T, A, B>(optic: PolyPrism<S, T, A, B>) => (SetPiece: B) => T

export declare const get: <S, T, A, B>(optic: PolyReversedPrism<S, T, A, B>) => (s: S) => A

export declare const getOption: <S, A>(optic: Getter<S, A>) => (s: S) => Option.Option<A>

export declare const getOrModify: <S, T, A, B>(optic: PolyOptional<S, T, A, B>) => (s: S) => Either.Either<A, T>

export declare const modify: <S, T, A, B>(optic: PolyOptional<S, T, A, B>) => (f: (a: A) => B) => (s: S) => T

export declare const polyReversedPrism: <S, T, A, B>(
  get: (s: S) => A,
  polyReplaceEither: (b: B) => (s: S) => Either.Either<T, readonly [Error, T]>
) => PolyReversedPrism<S, T, A, B>

export declare const replace: <S, T, A>(optic: PolySetter<S, T, A>) => (a: A) => (s: S) => T

export declare const replaceOption: <S, T, A>(optic: PolySetter<S, T, A>) => (a: A) => (s: S) => Option.Option<T>

export declare const reversedPrism: <S, A>(
  get: (s: S) => A,
  replaceEither: (a: A) => Either.Either<S, Error>
) => ReversedPrism<S, A>