import { Ord, Equal, NonEmptyArguments } from "@effect-ts-app/core/Prelude";
import { Order } from "@fp-ts/core/typeclass/Order";
import { NonEmptyArray, NonEmptyReadonlyArray } from "@fp-ts/data/ReadonlyArray";
import { Predicate } from "@fp-ts/data/Predicate";
import { Chunk } from "@fp-ts/data/Chunk";
import { Effect } from "@effect/io/Effect";
import * as Option from "./Option.js";
import * as Dur from "@fp-ts/data/Duration";
export * from "@fp-ts/data/ReadonlyArray";
/**
 * @tsplus getter ets/Ord toOrder
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function convertOrd<A>(_: Ord<A>): Order<A>;
/**
 * @tsplus getter Generator toArray
 * @tsplus getter Iterable toArray
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function toArray<A>(gen: Generator<A, void, unknown>): A[];
/**
 * Remove duplicates from an array, keeping the first occurrence of an element.
 * @tsplus pipeable Array uniq
 * @tsplus pipeable ReadonlyArray uniq
 * @tsplus static fp-ts/data/ReadonlyArray.Ops uniq
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function uniq<A>(E: Equal<A>): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
/**
 * @tsplus static fp-ts/data/Duration.Ops makeMillis
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare const millis_: (millis: number) => Dur.Duration;
export declare const isArray: (arg: any) => arg is any[];
/**
 * @tsplus static fp-ts/data/ReadonlyArray.Ops findFirstMap
 * @tsplus static Array.Ops findFirstMap
 * @tsplus pipeable Array findFirstMap
 * @tsplus pipeable fp-ts/data/ReadonlyArray findFirstMap
 * @tsplus pipeable ReadonlyArray findFirstMap
 * @tsplus pipeable NonEmptyArray findFirstMap
 * @tsplus pipeable NonEmptyArrayReadonlyArray findFirstMap
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function findFirstMap<A, B>(f: (a: A) => Option.Option<B>): (as: ReadonlyArray<A>) => Option.None | Option.Some<B>;
/**
 * @tsplus static fp-ts/data/ReadonlyArray.NonEmptyArray.Ops fromArray
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function NEAFromArray<T>(ar: Array<T>): Option.None | Option.Some<[T, ...T[]]>;
/**
 * @tsplus static fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray.Ops fromArray
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function NEROArrayFromArray<T>(ar: ReadonlyArray<T>): Option.None | Option.Some<readonly [T, ...T[]]>;
/**
 * @tsplus pipeable Array sortWith
 * @tsplus pipeable ReadonlyArray sortWith
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function sortWith<A>(...ords: NonEmptyArguments<Ord<A>>): (a: ReadonlyArray<A>) => ReadonlyArray<A>;
/**
 * @tsplus pipeable Array sortByO
 * @tsplus pipeable ReadonlyArray sortByO
 * @tsplus pipeable NonEmptyArray sortByO
 * @tsplus pipeable NonEmptyArrayReadonlyArray sortByO
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function sortByO<A>(ords: Option.Option<NonEmptyReadonlyArray<Ord<A>>>): (a: ReadonlyArray<A>) => ReadonlyArray<A>;
/**
 * @tsplus fluent ReadonlyArray groupByT
 * @tsplus fluent Array groupByT
 * @tsplus fluent NonEmptyArray groupByT
 * @tsplus fluent NonEmptyArrayReadonlyArray groupByT
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function groupByT<A, Key extends PropertyKey>(as: ReadonlyArray<A>, f: (a: A) => Key): ReadonlyArray<readonly [Key, NonEmptyReadonlyArray<A>]>;
/**
 * @tsplus operator ReadonlyArray &
 * @tsplus fluent ReadonlyArray concat
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function concat_<A, B>(self: ReadonlyArray<A>, that: ReadonlyArray<B>): ReadonlyArray<A | B>;
/**
 * Concatenates two ReadonlyArray together
 * @tsplus operator ReadonlyArray +
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare const concatOperator: <A>(self: ReadonlyArray<A>, that: ReadonlyArray<A>) => ReadonlyArray<A>;
/**
 * Prepends `a` to ReadonlyArray<A>
 * @tsplus operator ReadonlyArray + 1.0
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function prependOperatorStrict<A>(a: A, self: ReadonlyArray<A>): ReadonlyArray<A>;
/**
 * Prepends `a` to ReadonlyArray<A>
 * @tsplus operator ReadonlyArray >
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function prependOperator<A, B>(a: A, self: ReadonlyArray<B>): ReadonlyArray<A | B>;
/**
 * Prepends `a` to ReadonlyArray<A>
 * @tsplus fluent ReadonlyArray prepend
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function prepend_<A, B>(tail: ReadonlyArray<A>, head: B): ReadonlyArray<A | B>;
/**
 * Appends `a` to ReadonlyArray<A>
 * @tsplus fluent ReadonlyArray append
 * @tsplus operator ReadonlyArray <
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function append_<A, B>(init: ReadonlyArray<A>, end: B): ReadonlyArray<A | B>;
/**
 * @tsplus operator ReadonlyArray + 1.0
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare const appendOperator: <A>(self: ReadonlyArray<A>, a: A) => ReadonlyArray<A>;
/**
 * @tsplus fluent ReadonlyArray randomElement 1
 * @tsplus fluent Array randomElement 1
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function randomElement<A>(a: ReadonlyArray<A>): A;
/**
 * @tsplus fluent fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray randomElement 2
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function randomElementNA<A>(a: NonEmptyReadonlyArray<A>): A;
/**
 * @tsplus pipeable Array mapNonEmpty
 * @tsplus pipeable fp-ts/data/ReadonlyArray mapNonEmpty
 * @tsplus pipeable fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray mapNonEmpty
 * @tsplus pipeable fp-ts/data/ReadonlyArray.NonEmptyArray mapNonEmpty
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare const mapRA: <A, B>(f: (a: A) => B) => (self: readonly [A, ...A[]]) => [B, ...B[]];
/**
 * @tsplus fluent fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray sortBy
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function sortBy<A>(na: NonEmptyReadonlyArray<A>, ords: readonly Ord<A>[]): readonly [A, ...A[]];
/**
 * @tsplus static fp-ts/data/ReadonlyArray.Ops sortWithNonEmpty
 * @tsplus pipeable ReadonlyArray sortWithNonEmpty
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function sortWithNonEmpty<A>(...ords: NonEmptyArguments<Ord<A>>): (a: NonEmptyReadonlyArray<A>) => NonEmptyArray<A>;
/**
 * @tsplus static fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray __call
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare const makeNA: <Elements extends [any, ...any[]]>(...elements: Elements) => [Elements[number], ...Elements[number][]];
/**
 * @tsplus fluent ReadonlyArray filterWith
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function filterWith<A>(self: ReadonlyArray<A>, predicates: ReadonlyArray<Predicate<A>>): A[];
/**
 * Split the `items` array into multiple, smaller chunks of the given `size`.
 */
export declare function _chunk_<T>(items_: Iterable<T>, size: number): Generator<T[], void, unknown>;
/**
 * Split the `items` array into multiple, smaller chunks of the given `size`.
 * @tsplus fluent Array chunk
 * @tsplus fluent ReadonlyArray chunk
 * @tsplus fluent fp-ts/data/Chunk chunk
 * @tsplus fluent Iterable chunk
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function chunk_<T>(items_: Iterable<T>, size: number): import("@fp-ts/data/Chunk").Chunk<T[]>;
/**
 * @tsplus getter Array toChunk
 * @tsplus getter ReadonlyArray toChunk
 * @tsplus getter Iterable toChunk
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function toChunk<T>(items: Iterable<T>): import("@fp-ts/data/Chunk").Chunk<T>;
/**
 * @tsplus getter ReadonlyArray toNonEmpty
 * @tsplus getter Array toNonEmpty
 * @tsplus getter fp-ts/data/ReadonlyArray toNonEmpty
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare const toNonEmptyArray: <A>(a: readonly A[]) => Option.None | Option.Some<readonly [A, ...A[]]>;
/**
 * @tsplus getter Iterable toArray
 * @tsplus getter Iterator toArray
 * @tsplus getter Generator toArray
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare const iterableToArray: {
    <T>(arrayLike: ArrayLike<T>): T[];
    <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
    <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
    <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
};
/**
 * @tsplus getter Iterable toNonEmptyArray
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function CollectionToNonEmptyReadonlyArray<A>(c: Iterable<A>): Option.None | Option.Some<readonly [A, ...A[]]>;
/**
 * @tsplus getter fp-ts/data/Chunk toNonEmptyArray
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ChunkToNonEmptyReadonlyArray<A>(c: Chunk<A>): Option.None | Option.Some<readonly [A, ...A[]]>;
/**
 * @tsplus fluent Array forEachEffectPar
 * @tsplus fluent ReadonlyArray forEachEffectPar
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ext_forEachEffectPar<A, R, E, B>(as: ReadonlyArray<A>, f: (a: A) => Effect<R, E, B>): import("@effect/io/Effect").Effect<R, E, import("@fp-ts/data/Chunk").Chunk<B>>;
/**
 * @tsplus fluent fp-ts/data/Chunk forEachEffectPar
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ext_CNKforEachEffectPar<A, R, E, B>(as: Chunk<A>, f: (a: A) => Effect<R, E, B>): import("@effect/io/Effect").Effect<R, E, import("@fp-ts/data/Chunk").Chunk<B>>;
/**
 * @tsplus fluent fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray forEachEffectPar
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ext_NAforEachEffectPar<A, R, E, B>(as: NonEmptyReadonlyArray<A>, f: (a: A) => Effect<R, E, B>): import("@effect/io/Effect").Effect<R, E, readonly [B, ...B[]]>;
/**
 * @tsplus fluent fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray forEachEffect
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ext_NAforEach<A, R, E, B>(as: NonEmptyReadonlyArray<A>, f: (a: A) => Effect<R, E, B>): import("@effect/io/Effect").Effect<R, E, readonly [B, ...B[]]>;
/**
 * @tsplus fluent fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray forEachEffectWithIndexPar
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ext_NAforEachEffectWithIndexPar<A, R, E, B>(as: NonEmptyReadonlyArray<A>, f: (a: A, i: number) => Effect<R, E, B>): import("@effect/io/Effect").Effect<R, E, readonly [B, ...B[]]>;
/**
 * @tsplus fluent fp-ts/data/ReadonlyArray/NonEmptyReadonlyArray forEachEffectWithIndex
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ext_NAforEachWithIndex<A, R, E, B>(as: NonEmptyReadonlyArray<A>, f: (a: A, i: number) => Effect<R, E, B>): import("@effect/io/Effect").Effect<R, E, readonly [B, ...B[]]>;
/**
 * @tsplus fluent ReadonlyArray forEachEffectWithIndex
 * @tsplus fluent Array forEachEffectWithIndex
 * @tsplus fluent fp-ts/data/Chunk forEachEffectWithIndex
 * @tsplus fluent ets/Set forEachEffectWithIndex
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ext_forEachWithIndex<A, R, E, B>(as: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>): import("@effect/io/Effect").Effect<R, E, import("@fp-ts/data/Chunk").Chunk<B>>;
/**
 * @tsplus fluent ReadonlyArray forEachEffectParWithIndex
 * @tsplus fluent Array forEachEffectParWithIndex
 * @tsplus fluent fp-ts/data/Chunk forEachEffectParWithIndex
 * @tsplus fluent ets/Set forEachEffectParWithIndex
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare function ext_forEachParWithIndex<A, R, E, B>(as: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>): import("@effect/io/Effect").Effect<R, E, import("@fp-ts/data/Chunk").Chunk<B>>;
/**
 * @tsplus getter Iterable toChunk
 * @tsplus getter Iterator toChunk
 * @tsplus getter Generator toChunk
 * @tsplus location "@effect-ts-app/core/Array"
 */
export declare const ext_itToChunk: <A>(self: Iterable<A>) => import("@fp-ts/data/Chunk").Chunk<A>;
//# sourceMappingURL=Array.d.ts.map