import type { Eq } from "@principia/prelude/Eq";
import * as Ord from "@principia/prelude/Ord";
import type { Either } from "../Either";
import type { Predicate, Refinement } from "../Function";
import type { NonEmptyArray } from "../NonEmptyArray";
import type { Option } from "../Option";
export declare const append_: <A>(xs: readonly A[], ys: readonly A[]) => readonly A[];
export declare const append: <A>(ys: readonly A[]) => (xs: readonly A[]) => readonly A[];
export declare const lookup_: <A>(i: number, as: readonly A[]) => Option<A>;
export declare const lookup: (i: number) => <A>(as: readonly A[]) => Option<A>;
export declare const scanl: <A, B>(b: B, f: (b: B, a: A) => B) => (as: readonly A[]) => readonly B[];
export declare const scanr: <A, B>(b: B, f: (a: A, b: B) => B) => (as: readonly A[]) => readonly B[];
export declare const cons_: <A>(head: A, tail: readonly A[]) => NonEmptyArray<A>;
export declare const cons: <A>(tail: readonly A[]) => (head: A) => NonEmptyArray<A>;
export declare const snoc_: <A>(init: readonly A[], end: A) => NonEmptyArray<A>;
export declare const snoc: <A>(end: A) => (init: readonly A[]) => NonEmptyArray<A>;
export declare const head: <A>(as: readonly A[]) => Option<A>;
export declare const tail: <A>(as: readonly A[]) => Option<readonly A[]>;
export declare const last: <A>(as: readonly A[]) => Option<A>;
export declare const init: <A>(as: readonly A[]) => Option<readonly A[]>;
export declare const takel: (n: number) => <A>(as: readonly A[]) => readonly A[];
export declare const taker: (n: number) => <A>(as: readonly A[]) => readonly A[];
export declare const takelWhile: {
   <A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => ReadonlyArray<B>;
   <A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A>;
};
export interface Spanned<I, R> {
   readonly init: ReadonlyArray<I>;
   readonly rest: ReadonlyArray<R>;
}
export declare const spanl: {
   <A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => Spanned<B, A>;
   <A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Spanned<A, A>;
};
export declare const dropl: (n: number) => <A>(as: readonly A[]) => readonly A[];
export declare const dropr: (n: number) => <A>(as: readonly A[]) => readonly A[];
export declare const droprWhile: <A>(predicate: Predicate<A>) => (as: readonly A[]) => readonly A[];
export declare const findr: {
   <A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => Option<B>;
   <A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Option<A>;
};
export declare const findrMap: <A, B>(f: (a: A) => Option<B>) => (as: readonly A[]) => Option<B>;
export declare const findl: {
   <A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => Option<B>;
   <A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Option<A>;
};
export declare const findlMap: <A, B>(f: (a: A) => Option<B>) => (as: readonly A[]) => Option<B>;
export declare const findlIndex_: <A>(as: readonly A[], predicate: Predicate<A>) => Option<number>;
export declare const findlIndex: <A>(predicate: Predicate<A>) => (as: readonly A[]) => Option<number>;
export declare const findrIndex: <A>(predicate: Predicate<A>) => (as: readonly A[]) => Option<number>;
export declare const unsafeInsertAt: <A>(i: number, a: A, as: readonly A[]) => readonly A[];
export declare const unsafeUpdateAt: <A>(i: number, a: A, as: readonly A[]) => readonly A[];
export declare const unsafeDeleteAt: <A>(i: number, as: readonly A[]) => readonly A[];
export declare const insertAt_: <A>(as: readonly A[], i: number, a: A) => Option<readonly A[]>;
export declare const insertAt: <A>(i: number, a: A) => (as: readonly A[]) => Option<readonly A[]>;
export declare const updateAt_: <A>(as: readonly A[], i: number, a: A) => Option<readonly A[]>;
export declare const updateAt: <A>(i: number, a: A) => (as: readonly A[]) => Option<readonly A[]>;
export declare const deleteAt_: <A>(as: readonly A[], i: number) => Option<readonly A[]>;
export declare const deleteAt: (i: number) => <A>(as: readonly A[]) => Option<readonly A[]>;
/**
 * Apply a function to the element at the specified index, creating a new array, or returning `None` if the index is out
 * of bounds
 *
 * @since 1.0.0
 */
export declare const modifyAt_: <A>(as: readonly A[], i: number, f: (a: A) => A) => Option<readonly A[]>;
/**
 * Apply a function to the element at the specified index, creating a new array, or returning `None` if the index is out
 * of bounds
 *
 * @since 1.0.0
 */
export declare const modifyAt: <A>(i: number, f: (a: A) => A) => (as: readonly A[]) => Option<readonly A[]>;
export declare const reverse: <A>(as: readonly A[]) => readonly A[];
export declare const rights: <E, A>(as: readonly Either<E, A>[]) => readonly A[];
export declare const lefts: <E, A>(as: readonly Either<E, A>[]) => readonly E[];
export declare const sort: <B>(O: Ord.Ord<B>) => <A extends B>(as: readonly A[]) => readonly A[];
export declare const unzip: <A, B>(as: readonly (readonly [A, B])[]) => readonly [readonly A[], readonly B[]];
export declare const elem: <A>(E: Eq<A>) => (a: A) => (as: readonly A[]) => boolean;
export declare const uniq: <A>(E: Eq<A>) => (as: readonly A[]) => readonly A[];
export declare const sortBy: <B>(ords: readonly Ord.Ord<B>[]) => <A extends B>(as: readonly A[]) => readonly A[];
export declare const comprehension: {
   <A, B, C, D, R>(
      input: readonly [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>, ReadonlyArray<D>],
      f: (a: A, b: B, c: C, d: D) => R,
      g?: (a: A, b: B, c: C, d: D) => boolean
   ): ReadonlyArray<R>;
   <A, B, C, R>(
      input: readonly [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>],
      f: (a: A, b: B, c: C) => R,
      g?: (a: A, b: B, c: C) => boolean
   ): ReadonlyArray<R>;
   <A, B, R>(
      input: readonly [ReadonlyArray<A>, ReadonlyArray<B>],
      f: (a: A, b: B) => R,
      g?: (a: A, b: B) => boolean
   ): ReadonlyArray<R>;
   <A, R>(input: readonly [ReadonlyArray<A>], f: (a: A) => boolean, g?: (a: A) => R): ReadonlyArray<R>;
};
export declare const union: <A>(E: Eq<A>) => (ys: readonly A[]) => (xs: readonly A[]) => readonly A[];
export declare const intersection: <A>(E: Eq<A>) => (ys: readonly A[]) => (xs: readonly A[]) => readonly A[];
export declare const chop_: <A, B>(
   as: readonly A[],
   f: (as: NonEmptyArray<A>) => readonly [B, readonly A[]]
) => readonly B[];
export declare const chop: <A, B>(
   f: (as: NonEmptyArray<A>) => readonly [B, readonly A[]]
) => (as: readonly A[]) => readonly B[];
export declare const splitAt: (n: number) => <A>(as: readonly A[]) => readonly [readonly A[], readonly A[]];
export declare const chunksOf: (n: number) => <A>(as: readonly A[]) => readonly (readonly A[])[];
export declare const difference: <A>(E: Eq<A>) => (ys: readonly A[]) => (xs: readonly A[]) => readonly A[];
export declare const dropLeft_: <A>(as: readonly A[], n: number) => readonly A[];
export declare const dropLeft: (n: number) => <A>(as: readonly A[]) => readonly A[];
export declare const dropRight_: <A>(as: readonly A[], n: number) => readonly A[];
export declare const dropRight: (n: number) => <A>(as: readonly A[]) => readonly A[];
export declare const dropLeftWhile_: <A>(as: readonly A[], predicate: Predicate<A>) => readonly A[];
export declare const dropLeftWhile: <A>(predicate: Predicate<A>) => (as: readonly A[]) => readonly A[];
//# sourceMappingURL=combinators.d.ts.map