import { Kind } from '../../kinds/index.js';
import * as O from '../option';
import { TArray } from './array.types';
import * as tApplicative from '../../typeclass/applicative';
import * as tTraversable from '../../typeclass/traversable';
import * as tGroups from '../../typeclass/groups';
/**
 * produce an empty array of type a
 *
 * none :: `() -> a[]`
 *
 * none :: `<A>() => A[]`
 *
 * @returns `a[]`
 *
 * @example
 * ```ts
 * pipe(none(), map(x => x + 1)) // []
 * ```
 */
export declare const none: <A1>() => A1[];
/**
 * of :: a -> a[]
 * @param a : a
 * @returns fa: a[]
 *
 * @example
 * ```ts
 * pipe(1, of) // [1]
 * ```
 */
export declare const of: <A>(a: A) => A[];
/**
 * getOrElse :: (() -> b) -> a[] -> a | b
 *
 * getOrElse :: `<B>(f: () => B) => <A>(fa: A[]) => A | B`
 *
 * @param f : () -> b
 * @returns fa: a[] -> a | b
 *
 * @example
 * ```ts
 * pipe([1], getOrElse(() => 0)) // 1
 * pipe([], getOrElse(() => 0)) // 0
 * ```
 */
export declare const getOrElse: <A1>(f: () => A1) => <A>(fa: A[]) => A1 | A;
/**
 * get :: a[] -> Option<a>
 *
 * get :: `<A>(fa: A[]) => Option<A>`
 *
 * @param fa: a[]
 * @returns Option<a>
 *
 * @example
 * ```ts
 * pipe([1], get) // some(1)
 * pipe([], get) // none
 * ```
 */
export declare const get: <A1>(args_0: A1[]) => O.Option<A1>;
/**
 * getOr :: b -> a[] -> a | b
 *
 * getOr :: <B>(b: B) => <A>(fa: A[]) => A | B
 *
 * @param b : b
 * @returns fa: a[] -> a | b
 *
 * @example
 * ```ts
 * pipe([1], getOr(0)) // 1
 * pipe([], getOr(0)) // 0
 * ```
 */
export declare const getOr: <A1>(args_0: A1) => <B1>(args_0: B1[]) => A1 | B1;
/**
 * map :: (a -> b) -> a[] -> b[]
 * @param f : a -> b
 * @returns fa: a[] -> b[]
 *
 * @example
 * ```ts
 * pipe([1,2,3], map(x => x + 1)) // [2,3,4]
 * ```
 */
export declare const map: <A1, A2>(args_0: (args_0: A1) => A2) => (args_0: A1[]) => A2[];
/**
 * flap :: a -> (a -> b)[] -> b[]
 * @param a : a
 * @returns fab: (a -> b)[] -> b[]
 *
 * @example
 * ```ts
 * pipe([x => x + 1, x => x*2], flap(2)) // [3, 4]
 * ```
 */
export declare const flap: <A1>(args_0: A1) => <B1>(args_0: ((args_0: A1) => B1)[]) => B1[];
/**
 * as :: b -> a[] -> b[]
 * @param b : b
 * @returns fa: a[] -> b[]
 *
 * @example
 * ```ts
 * pipe([1,2,3], as(0)) // [0,0,0]
 * ```
 */
export declare const as: <A1>(args_0: A1) => <B1>(args_0: B1[]) => A1[];
/**
 * doubleMap :: (a -> b) -> a[][] -> b[][]
 * @param f : a -> b
 * @returns fa: a[][] -> b[][]
 *
 * @example
 * ```ts
 * pipe([[1,2,3],[4,5,6]], doubleMap(x => x + 1)) // [[2,3,4],[5,6,7]]
 * ```
 */
export declare const doubleMap: <A1, A2>(args_0: (args_0: A1) => A2) => (args_0: A1[][]) => A2[][];
/**
 * ap :: `a[] -> (a -> b)[] -> b[]`
 *
 * ap :: `<A, B>(fa: A[]) => (fab: (a: A) => B[]) => B[]`
 *
 * @param fa `a[]`
 * @returns `(a -> b)[] -> b[]`
 *
 * @example
 * ```ts
 * pipe(of(x=>x+1), ap([1,2,3])) // [2,3,4]
 */
export declare const ap: <A1>(args_0: A1[]) => <B1>(args_0: ((args_0: A1) => B1)[]) => B1[];
/**
 * liftA2 :: `(a b -> c) -> a[] -> b[] -> c[]`
 *
 * liftA2 :: `<A, B, C>(f: (a: A, b: B) => C) => (fa: A[]) => (fb: B[]) => C[]`
 *
 * @param f `(a b -> c)`
 * @returns `a[] -> b[] -> c[]`
 *
 * @example
 * ```ts
 * pipe([1,2,3],pipe([1,2,3],liftA2((a, b) => a + b))) // [2,3,4,3,4,5,4,5,6]
 * pipe([1,2,3],pipe([1,2,3],liftA2((a,b)=> [a,b]))) // [[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],[3,1],[3,2],[3,3]]
 * ```
 */
export declare const liftA2: <A1, A2, A3>(args_0: (args_0: A1, args_1: A2) => A3) => (args_0: A1[]) => (args_0: A2[]) => A3[];
/**
 * product :: `a[] -> b[] -> [a, b][]`
 *
 * product :: `<A, B>(fa: A[]) => (fb: B[]) => [A, B][]`
 *
 * @param fa `a[]`
 * @returns `b[] -> [a, b][]`
 *
 * @example
 * ```ts
 * pipe([1,2,3], product([1,2,3])) // [[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],[3,1],[3,2],[3,3]]
 * ```
 */
export declare const aproduct: <A1>(args_0: A1[]) => <B1>(args_0: B1[]) => [A1, B1][];
/**
 * productMany :: `a[] -> a[][] -> a[][]`
 *
 * productMany :: `<A>(fa: A[]) => (faa: A[][]) => A[][]`
 *
 * @param fa `a[]`
 * @returns `a[][] -> a[][]`
 *
 * @example
 * ```ts
 * pipe([[1,2,3],[4,5,6]], productMany([1,2,3])) // [[1,1,4],[1,1,5],[1,1,6],[1,2,4],[1,2,5],[1,2,6],[1,3,4],[1,3,5],[1,3,6],[2,1,4],[2,1,5],[2,1,6],[2,2,4],[2,2,5],[2,2,6],[2,3,4],[2,3,5],[2,3,6],[3,1,4],[3,1,5],[3,1,6],[3,2,4],[3,2,5],[3,2,6],[3,3,4],[3,3,5],[3,3,6]]
 * ```
 */
export declare const productMany: <A1>(args_0: A1[]) => (args_0: A1[][]) => A1[][];
/**
 * zipWith :: `(a b -> c) -> a[] -> b[] -> c[]`
 *
 * zipWith :: `<A, B, C>(f: (a: A, b: B) => C) => (fa: A[]) => (fb: B[]) => C[]`
 *
 * @param f `(a b -> c)`
 * @returns `a[] -> b[] -> c[]`
 *
 * @example
 * ```ts
 * pipe([1,2,3], pipe([1,2,3], zipWith((a, b) => a + b))) // [2,4,6]
 * ```
 */
export declare const zipWith: <A1, A2, A3>(args_0: (args_0: A1, args_1: A2) => A3) => (args_0: A1[]) => (args_0: A2[]) => A3[];
/**
 * zip :: `a[] -> b[] -> [a, b][]`
 *
 * zip :: `<A, B>(fa: A[]) => (fb: B[]) => [A, B][]`
 *
 * @param fa `a[]`
 * @returns `b[] -> [a, b][]`
 *
 * @example
 * ```ts
 * pipe([4,5,6], zip([1,2,3])) // [[1,4],[2,5],[3,6]]
 * ```
 */
export declare const zip: <A1>(args_0: A1[]) => <B1>(args_0: B1[]) => [A1, B1][];
/**
 * flatMap :: `(a -> b[]) -> a[] -> b[]`
 *
 * flatMap :: `<A, B>(f: (a: A) => B[]) => (fa: A[]) => B[]`
 *
 * @param f `(a -> b[])`
 * @returns `a[] -> b[]`
 *
 * @example
 * ```ts
 * pipe([1,2,3], flatMap(x => [x, x+1])) // [1,2,2,3,3,4]
 * ```
 */
export declare const flatMap: <A1, A2>(args_0: (args_0: A1) => A2[]) => (args_0: A1[]) => A2[];
/**
 * flatten :: a[][] -> a[]
 *
 * flatten :: `<A>(faa: A[][]) => A[]`
 *
 * @param faa `a[][]`
 * @returns `a[]`
 *
 * @example
 * ```ts
 * pipe([[1,2,3],[4,5,6]], flatten) // [1,2,3,4,5,6]
 * ```
 */
export declare const flatten: <A1>(args_0: A1[][]) => A1[];
/**
 * tap :: `(a -> void) -> a[] -> a[]`
 *
 * tap :: `<A>(f: (a: A) => void) => (fa: A[]) => A[]`
 *
 * @param f `(a -> void)`
 * @returns `a[] -> a[]`
 *
 * @example
 * ```ts
 * pipe([1,2,3], tap(console.log)) // [1,2,3]
 * ```
 */
export declare const tap: <A1>(args_0: (args_0: A1) => void) => (args_0: A1[]) => A1[];
/**
 * reduce :: `(b a -> b) b -> a[] -> b`
 *
 * reduce :: `<A, B>(f: (b: B, a: A) => B, b: B) => (fa: A[]) => B`
 *
 * @param f `(b a -> b)`
 * @param b `b`
 * @returns `a[] -> b`
 *
 * @example
 * ```ts
 * pipe([1,2,3], reduce((b, a) => b + a, 0)) // 6
 * ```
 */
export declare const reduce: <A1, A2>(args_0: (args_0: A1, args_1: A2) => A1, args_1: A1) => (args_0: A2[]) => A1;
export declare const reduceRight: <A, B>(f: (acc: B, item: A) => B, init: B) => (fa: A[]) => B;
export declare const scan: <A, B>(f: (b: B, a: A) => B, init: B) => (fa: A[]) => B[];
export declare const scanRight: <A, B>(f: (b: B, a: A) => B, init: B) => (fa: A[]) => B[];
/**
 * filterMap :: `(a -> Option<b>) -> a[] -> b[]`
 *
 * filterMap :: `<A, B>(f: (a: A) => Option<B>) => (fa: A[]) => B[]`
 *
 * @param f `(a -> Option<b>)`
 * @returns `a[] -> b[]`
 *
 * @example
 * ```ts
 * pipe([1,2,3], filterMap(x => x > 1 ? some(x) : none)) // [2,3]
 * ```
 */
export declare const filterMap: <A1, A2>(args_0: (args_0: A1) => O.Option<A2>) => (args_0: A1[]) => A2[];
/**
 * filter :: `(a -> boolean) -> a[] -> a[]`
 *
 * filter :: `<A>(f: (a: A) => boolean) => (fa: A[]) => A[]`
 *
 * @param f `(a -> boolean)`
 * @returns `a[] -> a[]`
 *
 * @example
 * ```ts
 * pipe([1,2,3], filter(x => x > 1)) // [2,3]
 * ```
 */
export declare const filter: <A1>(args_0: (args_0: A1) => boolean) => (args_0: A1[]) => A1[];
/**
 * compact :: Option<a>[] -> a[]
 *
 * compact :: `<A>(fa: Option<A>[]) => A[]`
 *
 * @param fa `Option<a>[]`
 * @returns `a[]`
 *
 * @example
 * ```ts
 * pipe([some(1), none, some(2)], compact) // [1,2]
 * ```
 */
export declare const compact: <A1>(args_0: O.Option<A1>[]) => A1[];
export declare const traverse: <F extends Kind>(F: tApplicative.Applicative<F>) => tTraversable.Traversable.$traverse<TArray, F>;
export declare const sequence: <F extends Kind>(F: tApplicative.Applicative<F>) => tTraversable.Traversable.$sequence<TArray, F>;
export declare const range: (start: number, end: number, step?: number) => number[];
export declare const orElse: <A1>(args_0: () => A1[]) => (args_0: A1[]) => A1[];
export declare const or: <A1>(args_0: A1[]) => (args_0: A1[]) => A1[];
export declare const concat: <A1>(args_0: A1[]) => (args_0: A1[]) => A1[];
export declare const concatMany: <A>(...faa: A[][]) => A[];
export declare const append: <A>(a: A) => (args_0: A[]) => A[];
export declare const prepend: <A>(a: A) => (fa: A[]) => A[];
export declare const pluck: <A, K extends keyof A>(k: K) => (args_0: A[]) => A[K][];
export declare const takeWhile: <A>(f: (a: A) => boolean) => (fa: A[]) => A[];
export declare const take: (count: number) => <A>(fa: A[]) => A[];
export declare const dropWhile: <A>(f: (a: A) => boolean) => (fa: A[]) => A[];
export declare const drop: (count: number) => <A>(fa: A[]) => A[];
export declare const head: <A>(fa: A[]) => O.Option<A>;
export declare const tail: <A>(fa: A[]) => A[];
export declare const list: <A>(fa: A[]) => [A, A[]];
export declare const last: <A>(fa: A[]) => O.Option<A>;
export declare const enumerate: <A>(fa: A[]) => [A, number][];
export declare const unique: <A>(fa: A[]) => A[];
export declare const duplicate: <A>(args_0: A[]) => A[];
export declare const reverse: <A>(fa: A[]) => A[];
export declare const some: <A>(f: (a: A) => boolean) => (fa: A[]) => boolean;
export declare const every: <A>(f: (a: A) => boolean) => (fa: A[]) => boolean;
export declare const find: <A>(f: (a: A) => boolean) => (fa: A[]) => O.Option<A>;
export declare const findIndex: <A>(f: (a: A) => boolean) => (fa: A[]) => O.Option<number>;
export declare const findLast: <A>(f: (a: A) => boolean) => (fa: A[]) => O.Option<A>;
export declare const findLastIndex: <A>(f: (a: A) => boolean) => (fa: A[]) => O.Option<number>;
export declare const includes: <A>(a: A) => (fa: A[]) => boolean;
export declare const isEmpty: <A>(fa: A[]) => boolean;
export declare const count: <A>(fa: A[]) => number;
export declare const length: <A>(fa: A[]) => number;
export declare const fold: <A>(monoid: tGroups.Monoid<A>) => (args_0: A[]) => A;
export declare const sum: (args_0: number[]) => number;
export declare const product: (args_0: number[]) => number;
export declare const max: (args_0: number[]) => number;
export declare const min: (args_0: number[]) => number;
export declare const alternateFold: <A>(group: tGroups.Group<A>) => (fa: A[]) => A;
export declare const alternateSum: (fa: number[]) => number;
export declare const alternateProduct: (fa: number[]) => number;
export declare const join: (separator: string) => (fa: string[]) => string;
export declare const joinAll: (args_0: string[]) => string;
export declare const biggest: (args_0: string[]) => string;
export declare const smallestNonEmpty: (args_0: string[]) => string;
export declare const split: (separator: string) => (fa: string) => string[];