import type { Eq } from "@principia/prelude/Eq";
import type { Ord } from "@principia/prelude/Ord";
import type { Option } from "../Option";
import type { ReadonlyRecord } from "../Record";
import type { NonEmptyArray } from "./model";
export declare const head: <A>(as: NonEmptyArray<A>) => A;
export declare const tail: <A>(as: NonEmptyArray<A>) => readonly A[];
export declare const reverse: <A>(as: NonEmptyArray<A>) => NonEmptyArray<A>;
export declare const min: <A>(O: Ord<A>) => (as: NonEmptyArray<A>) => A;
export declare const max: <A>(O: Ord<A>) => (as: NonEmptyArray<A>) => A;
export declare function append_<A>(xs: ReadonlyArray<A>, ys: NonEmptyArray<A>): NonEmptyArray<A>;
export declare function append_<A>(xs: NonEmptyArray<A>, ys: ReadonlyArray<A>): NonEmptyArray<A>;
export declare function append<A>(ys: NonEmptyArray<A>): (xs: ReadonlyArray<A>) => NonEmptyArray<A>;
export declare function append<A>(ys: ReadonlyArray<A>): (xs: ReadonlyArray<A>) => NonEmptyArray<A>;
/**
 * Group equal, consecutive elements of an array into non empty arrays.
 *
 * @category Combinators
 * @since 1.0.0
 */
export declare function group<A>(
   E: Eq<A>
): {
   (as: NonEmptyArray<A>): NonEmptyArray<NonEmptyArray<A>>;
   (as: ReadonlyArray<A>): ReadonlyArray<NonEmptyArray<A>>;
};
/**
 * Sort and then group the elements of an array into non empty arrays.
 *
 * @category Combinators
 * @since 1.0.0
 */
export declare const groupSort: <A>(O: Ord<A>) => (as: readonly A[]) => readonly NonEmptyArray<A>[];
/**
 * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning
 * function on each element, and grouping the results according to values returned
 *
 * @category Combinators
 * @since 1.0.0
 */
export declare const groupBy: <A>(
   f: (a: A) => string
) => (as: readonly A[]) => Readonly<Record<string, NonEmptyArray<A>>>;
/**
 * Get the last elements of a non empty array
 *
 * @since 1.0.0
 */
export declare const last: <A>(as: NonEmptyArray<A>) => A;
/**
 * Get all but the last element of a non empty array, creating a new array.
 *
 * @since 1.0.0
 */
export declare const init: <A>(as: NonEmptyArray<A>) => readonly A[];
/**
 * @category Combinators
 * @since 1.0.0
 */
export declare const sort: <A>(O: Ord<A>) => (as: NonEmptyArray<A>) => NonEmptyArray<A>;
export declare const insertAt_: <A>(as: NonEmptyArray<A>, i: number, a: A) => Option<NonEmptyArray<A>>;
export declare const insertAt: <A>(i: number, a: A) => (as: NonEmptyArray<A>) => Option<NonEmptyArray<A>>;
export declare const updateAt_: <A>(as: NonEmptyArray<A>, i: number, a: A) => Option<NonEmptyArray<A>>;
export declare const updateAt: <A>(i: number, a: A) => (as: NonEmptyArray<A>) => Option<NonEmptyArray<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: NonEmptyArray<A>, i: number, f: (a: A) => A) => Option<NonEmptyArray<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: NonEmptyArray<A>) => Option<NonEmptyArray<A>>;
/**
 * @since 1.0.0
 */
export declare const unzip: <A, B>(as: NonEmptyArray<readonly [A, B]>) => readonly [NonEmptyArray<A>, NonEmptyArray<B>];
//# sourceMappingURL=combinators.d.ts.map