@fncts/base 0.0.1

package/collection/immutable/ImmutableArray/api.d.ts

@@ -0,0 +1,680 @@
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { These } from "@fncts/base/data/These/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { ImmutableNonEmptyArray, NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Eval } from "@fncts/base/control/Eval/definition";
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import type { Monoid } from "@fncts/base/typeclass";
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus fluent fncts.ImmutableArray alignWith
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function alignWith_<A, B, C>(self: ImmutableArray<A>, fb: ImmutableArray<B>, f: (_: These<A, B>) => C): ImmutableArray<C>;
+/**
+ * @tsplus fluent fncts.ImmutableArray align
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function align_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<These<A, B>>;
+/**
+ * @tsplus fluent fncts.ImmutableArray alt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function alt_<A, B>(self: ImmutableArray<A>, that: Lazy<ImmutableArray<B>>): ImmutableArray<A | B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray ap
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function ap_<A, B>(self: ImmutableArray<(a: A) => B>, fa: ImmutableArray<A>): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray append
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function append_<A, B>(self: ImmutableArray<A>, last: B): ImmutableArray<A | B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray crossWith
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function crossWith_<A, B, C>(self: ImmutableArray<A>, fb: ImmutableArray<B>, f: (a: A, b: B) => C): ImmutableArray<C>;
+/**
+ * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function chainRecDepthFirst<A, B>(a: A, f: (a: A) => ImmutableArray<Either<A, B>>): ImmutableArray<B>;
+/**
+ * @tsplus static fncts.ImmutableArrayOps chainRecBreadthFirst
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function chainRecBreadthFirst<A, B>(a: A, f: (a: A) => ImmutableArray<Either<A, B>>): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray flatMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function flatMapWithIndex_<A, B>(self: ImmutableArray<A>, f: (i: number, a: A) => ImmutableArray<B>): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray flatMap
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function flatMap_<A, B>(self: ImmutableArray<A>, f: (a: A) => ImmutableArray<B>): ImmutableArray<B>;
+/**
+ * @tsplus getter fncts.ImmutableArray flatten
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function flatten<A>(self: ImmutableArray<ImmutableArray<A>>): ImmutableArray<A>;
+/**
+ * A useful recursion pattern for processing a `Array` to produce a new `Array`,
+ * often used for "chopping" up the input `Array`. Typically chop is called with some function
+ * that will consume an initial prefix of the `Array` and produce a value and the rest of the `Array`.
+ * @tsplus fluent fncts.ImmutableArray chop
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function chop_<A, B>(as: ImmutableArray<A>, f: (as: ImmutableNonEmptyArray<A>) => readonly [B, ImmutableArray<A>]): ImmutableArray<B>;
+/**
+ * @tsplus pipeable fncts.ImmutableArray chop
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const chop: <A, B>(f: (as: import("../ImmutableNonEmptyArray").ImmutableNonEmptyArray<A>) => readonly [B, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>]) => (as: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray chunksOf
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function chunksOf_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<ImmutableArray<A>>;
+/**
+ * @tsplus fluent fncts.ImmutableArray collectWhile
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function collectWhile_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): ImmutableArray<B>;
+/**
+ * @tsplus static fncts.ImmutableArrayOps comprehension
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function comprehension<A, B, C, D, R>(input: [ImmutableArray<A>, ImmutableArray<B>, ImmutableArray<C>, ImmutableArray<D>], f: (a: A, b: B, c: C, d: D) => R, g?: (a: A, b: B, c: C, d: D) => boolean): ImmutableArray<R>;
+export declare function comprehension<A, B, C, R>(input: [ImmutableArray<A>, ImmutableArray<B>, ImmutableArray<C>], f: (a: A, b: B, c: C) => R, g?: (a: A, b: B, c: C) => boolean): ImmutableArray<R>;
+export declare function comprehension<A, B, R>(input: [ImmutableArray<A>, ImmutableArray<B>], f: (a: A, b: B) => R, g?: (a: A, b: B) => boolean): ImmutableArray<R>;
+export declare function comprehension<A, R>(input: [ImmutableArray<A>], f: (a: A) => R, g?: (a: A) => boolean): ImmutableArray<R>;
+/**
+ * @tsplus fluent fncts.ImmutableArray concat
+ * @tsplus operator fncts.ImmutableArray +
+ * @tsplus operator fncts.base.MutableArray +
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function concat_<A, B>(self: ImmutableArray<A>, that: ImmutableArray<B>): ImmutableArray<A | B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray deleteAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function deleteAt_<A>(as: ImmutableArray<A>, i: number): Maybe<ImmutableArray<A>>;
+/**
+ * @constrained
+ */
+export declare function difference_<A>(E: P.Eq<A>): (self: ImmutableArray<A>, ys: ImmutableArray<A>) => ImmutableArray<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray difference
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function differenceSelf<A>(self: ImmutableArray<A>): (E: P.Eq<A>) => (that: ImmutableArray<A>) => ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray drop
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function drop_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray dropLast
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function dropLast_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray dropWhile
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function dropWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray dropLastWhile
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function dropLastWhile_<A>(as: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
+/**
+ * Test if a value is a member of an array. Takes an `Eq<A>` as a single
+ * argument which returns the function to use to search for a value of type `A` in
+ * an array of type `ImmutableArray<A>`.
+ *
+ * @constrained
+ */
+export declare function elem_<A>(E: P.Eq<A>): (as: ImmutableArray<A>, a: A) => boolean;
+/**
+ * Test if a value is a member of an array. Takes an `Eq<A>` as a single
+ * argument which returns the function to use to search for a value of type `A` in
+ * an array of type `ImmutableArray<A>`.
+ * @tsplus getter fncts.ImmutableArray elem
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function elemSelf<A>(self: ImmutableArray<A>): (E: P.Eq<A>) => (a: A) => boolean;
+/**
+ * @tsplus fluent fncts.ImmutableArray every
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function every_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): self is ImmutableArray<B>;
+export declare function every_<A>(self: ImmutableArray<A>, p: Predicate<A>): boolean;
+/**
+ * @tsplus fluent fncts.ImmutableArray everyWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function everyWithIndex_<A, B extends A>(self: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): self is ImmutableArray<B>;
+export declare function everyWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): boolean;
+/**
+ * @tsplus fluent fncts.ImmutableArray exists
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function exists_<A>(self: ImmutableArray<A>, p: Predicate<A>): self is ImmutableNonEmptyArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray filter
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function filter_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): ImmutableArray<B>;
+export declare function filter_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray filterWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function filterWithIndex_<A, B extends A>(self: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): ImmutableArray<B>;
+export declare function filterWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray filterMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function filterMapWithIndex_<A, B>(fa: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray filterMap
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function filterMap_<A, B>(self: ImmutableArray<A>, f: (a: A) => Maybe<B>): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray find
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function find_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): Maybe<B>;
+export declare function find_<A>(self: ImmutableArray<A>, p: Predicate<A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray findIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function findIndex_<A>(as: ImmutableArray<A>, predicate: Predicate<A>): Maybe<number>;
+/**
+ * @tsplus fluent fncts.ImmutableArray findWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function findWithIndex_<A, B extends A>(as: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): Maybe<B>;
+export declare function findWithIndex_<A>(as: ImmutableArray<A>, p: PredicateWithIndex<number, A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray findMap
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function findMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): Maybe<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray findMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function findMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (index: number, a: A) => Maybe<B>): Maybe<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray findLast
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function findLast_<A, B extends A>(as: ImmutableArray<A>, p: Refinement<A, B>): Maybe<B>;
+export declare function findLast_<A>(as: ImmutableArray<A>, p: Predicate<A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function findLastIndex_<A>(self: ImmutableArray<A>, p: Predicate<A>): Maybe<number>;
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastMap
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function findLastMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): Maybe<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function findLastMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): Maybe<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
+ * @tsplus fluent fncts.base.MutableArray foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeft
+ * @tsplus fluent fncts.base.MutableArray foldLeft
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWhile
+ * @tsplus fluent fncts.base.MutableArray foldLeftWhile
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
+ * @tsplus fluent fncts.base.MutableArray foldLeftWithIndexWhile
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldLeftWithIndexWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (i: number, b: B, a: A) => B): B;
+export declare function fold<M>(M: Monoid<M>): (self: ImmutableArray<M>) => M;
+/**
+ * @tsplus fluent fncts.ImmutableArray fold
+ * @tsplus fluent fncts.base.MutableArray fold
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldSelf<M>(self: ImmutableArray<M>, M: Monoid<M>): M;
+/**
+ * @constrained
+ */
+export declare function foldMapWithIndex_<M>(M: Monoid<M>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>, f: (i: number, a: A) => M) => M;
+/**
+ * @tsplus getter fncts.ImmutableArray foldMapWithIndex
+ * @tsplus getter fncts.base.MutableArray foldMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldMapWithIndexSelf<A>(self: ImmutableArray<A>): <M>(M: Monoid<M>) => (f: (i: number, a: A) => M) => M;
+/**
+ * @constrained
+ */
+export declare function foldMap_<M>(M: Monoid<M>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>, f: (a: A) => M) => M;
+/**
+ * @tsplus getter fncts.ImmutableArray foldMap
+ * @tsplus getter fncts.base.MutableArray foldMap
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldMapSelf<A>(self: ImmutableArray<A>): <M>(M: Monoid<M>) => (f: (a: A) => M) => M;
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
+ * @tsplus fluent fncts.base.MutableArray foldRightWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldRightWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, a: A, b: B) => B): B;
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRight
+ * @tsplus fluent fncts.base.MutableArray foldRight
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A, b: B) => B): B;
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRighWhile
+ * @tsplus fluent fncts.base.MutableArray foldRightWhile
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldRightWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (a: A, b: B) => B): B;
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
+ * @tsplus fluent fncts.base.MutableArray foldRightWithIndexWhile
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function foldRightWithIndexWhile_<A, B>(self: ImmutableArray<A>, b: B, predicate: Predicate<B>, f: (i: number, a: A, b: B) => B): B;
+/**
+ * @tsplus fluent fncts.ImmutableArray forEach
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function forEach_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): void;
+/**
+ * @tsplus fluent fncts.ImmutableArray get
+ * @tsplus fluent fncts.base.MutableArray get
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function get_<A>(self: ImmutableArray<A>, i: number): Maybe<A>;
+export declare function group<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<ImmutableNonEmptyArray<A>>;
+/**
+ * @tsplus fluent fncts.ImmutableArray group
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function chopSelf<A>(self: ImmutableArray<A>, E: P.Eq<A>): ImmutableArray<ImmutableNonEmptyArray<A>>;
+/**
+ * @tsplus fluent fncts.ImmutableArray groupBy
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function groupBy_<A>(self: ImmutableArray<A>, f: (a: A) => string): Readonly<Record<string, ImmutableNonEmptyArray<A>>>;
+/**
+ * @tsplus getter fncts.ImmutableArray head
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function head<A>(self: ImmutableArray<A>): Maybe<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray init
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function init<A>(self: ImmutableArray<A>): Maybe<ImmutableArray<A>>;
+/**
+ * @tsplus fluent fncts.ImmutableArray insertAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function insertAt_<A>(self: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableNonEmptyArray<A>>;
+export declare function intersection_<A>(E: P.Eq<A>): (self: ImmutableArray<A>, that: ImmutableArray<A>) => ImmutableArray<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray intersection
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function intersectionSelf<A>(self: ImmutableArray<A>): (E: P.Eq<A>) => (that: ImmutableArray<A>) => ImmutableArray<A>;
+export declare function intersperse_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray isEmpty
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function isEmpty<A>(self: ImmutableArray<A>): boolean;
+/**
+ * @tsplus fluent fncts.ImmutableArray isNonEmpty
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function isNonEmpty<A>(self: ImmutableArray<A>): self is ImmutableNonEmptyArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray isOutOfBound
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function isOutOfBound_<A>(self: ImmutableArray<A>, i: number): boolean;
+/**
+ * @tsplus fluent fncts.ImmutableArray join
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function join(self: ImmutableArray<string>, separator: string): string;
+/**
+ * @tsplus getter fncts.ImmutableArray last
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function last<A>(self: ImmutableArray<A>): Maybe<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray length
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function length<A>(self: ImmutableArray<A>): number;
+/**
+ * @tsplus getter fncts.ImmutableArray lefts
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function lefts<E, A>(self: ImmutableArray<Either<E, A>>): ImmutableArray<E>;
+/**
+ * @tsplus fluent fncts.ImmutableArray map
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function map_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray mapAccum
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function mapAccum_<A, S, B>(self: ImmutableArray<A>, s: S, f: (s: S, a: A) => readonly [B, S]): readonly [ImmutableArray<B>, S];
+/**
+ * @tsplus fluent fncts.ImmutableArray mapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function mapWithIndex_<A, B>(self: ImmutableArray<A>, f: (i: number, a: A) => B): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray modifyAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function modifyAt_<A>(self: ImmutableArray<A>, i: number, f: (a: A) => A): Maybe<ImmutableArray<A>>;
+/**
+ * @tsplus fluent fncts.ImmutableArray mutate
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function mutate_<A>(self: ImmutableArray<A>, f: (self: Array<A>) => void): ImmutableArray<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray mutableClone
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function mutableClone<A>(self: ImmutableArray<A>): Array<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray partitionWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function partitionWithIndex_<A, B extends A>(self: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): readonly [ImmutableArray<A>, ImmutableArray<B>];
+export declare function partitionWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+/**
+ * @tsplus fluent fncts.ImmutableArray partition
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function partition_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): readonly [ImmutableArray<A>, ImmutableArray<B>];
+export declare function partition_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+/**
+ * @tsplus fluent fncts.ImmutableArray partitionMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function partitionMapWithIndex_<A, B, C>(self: ImmutableArray<A>, f: (i: number, a: A) => Either<B, C>): readonly [ImmutableArray<B>, ImmutableArray<C>];
+/**
+ * @tsplus fluent fncts.ImmutableArray partitionMap
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function partitionMap_<A, B, C>(self: ImmutableArray<A>, f: (a: A) => Either<B, C>): readonly [ImmutableArray<B>, ImmutableArray<C>];
+/**
+ * @tsplus fluent fncts.ImmutableArray prepend
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function prepend_<A, B>(self: ImmutableArray<A>, head: B): ImmutableArray<A | B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray prependAll
+ * @tsplus fluent fncts.base.MutableArray prependAll
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function prependAll_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray reverse
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function reverse<A>(self: ImmutableArray<A>): ImmutableArray<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray rights
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function rights<E, A>(self: ImmutableArray<Either<E, A>>): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray rotate
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function rotate_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray scanLeft
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function scanLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray scanRight
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function scanRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A, b: B) => B): ImmutableArray<B>;
+/**
+ * @tsplus fluent fncts.ImmutableArray sort
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function sort<A extends B, B>(self: ImmutableArray<A>, O: P.Ord<B>): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray sortBy
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function sortBy<A extends B, B>(self: ImmutableArray<A>, Os: ImmutableArray<P.Ord<B>>): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray spanLeft
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function spanLeft_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): readonly [ImmutableArray<B>, ImmutableArray<A>];
+export declare function spanLeft_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+/**
+ * @tsplus fluent fncts.ImmutableArray spanRight
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function spanRight_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): readonly [ImmutableArray<A>, ImmutableArray<B>];
+export declare function spanRight_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+/**
+ * @tsplus fluent fncts.ImmutableArray spanIndexLeft
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function spanIndexLeft_<A>(self: ImmutableArray<A>, p: Predicate<A>): number;
+/**
+ * @tsplus fluent fncts.ImmutableArray spanIndexRight
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function spanIndexRight_<A>(as: ImmutableArray<A>, predicate: Predicate<A>): number;
+/**
+ * @tsplus fluent fncts.ImmutableArray slice
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function slice_<A>(self: ImmutableArray<A>, start?: number, end?: number): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray splitAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function splitAt_<A>(as: ImmutableArray<A>, n: number): readonly [ImmutableArray<A>, ImmutableArray<A>];
+/**
+ * @tsplus fluent fncts.ImmutableArray splitWhere
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function splitWhere_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare const sequence: P.sequence<ImmutableArrayF>;
+/**
+ * @tsplus getter fncts.ImmutableArray sequence
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const sequenceSelf: P.sequenceSelf<ImmutableArrayF>;
+/**
+ * @tsplus getter fncts.ImmutableArray tail
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function tail<A>(self: ImmutableArray<A>): Maybe<ImmutableArray<A>>;
+/**
+ * @tsplus fluent fncts.ImmutableArray take
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function take_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray takeLast
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function takeLast_<A>(as: ImmutableArray<A>, n: number): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray takeWhile
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function takeWhile_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): ImmutableArray<B>;
+export declare function takeWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
+export declare const traverseWithIndex_: P.traverseWithIndex_<ImmutableArrayF>;
+/**
+ * @tsplus dataFirst traverseWithIndex_
+ */
+export declare const traverseWithIndex: P.traverseWithIndex<ImmutableArrayF>;
+/**
+ * @tsplus getter fncts.ImmutableArray traverseWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const traverseWithIndexSelf: P.traverseWithIndexSelf<ImmutableArrayF>;
+export declare const traverse_: P.traverse_<ImmutableArrayF>;
+/**
+ * @tsplus dataFirst traverse_
+ */
+export declare const traverse: P.traverse<ImmutableArrayF>;
+/**
+ * @tsplus getter fncts.ImmutableArray traverse
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const traverseSelf: P.traverseSelf<ImmutableArrayF>;
+export declare function union_<A>(E: P.Eq<A>): (self: ImmutableArray<A>, that: ImmutableArray<A>) => ImmutableArray<A>;
+export declare function uniq<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray uniq
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function uniqSelf<A>(self: ImmutableArray<A>, E: P.Eq<A>): ImmutableArray<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray unprepend
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function unprepend<A>(self: ImmutableArray<A>): Maybe<readonly [A, ImmutableArray<A>]>;
+/**
+ * @tsplus index fncts.ImmutableArray
+ */
+export declare function unsafeGet<A>(self: ImmutableArray<A>, i: number): A | undefined;
+/**
+ * @tsplus getter fncts.ImmutableArray unsafeAsMutable
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function unsafeAsMutable<A>(self: ImmutableArray<A>): Array<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeDeleteAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function unsafeDeleteAt_<A>(self: ImmutableArray<A>, i: number): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeInsertAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function unsafeInsertAt_<A>(as: ImmutableArray<A>, i: number, a: A): ImmutableNonEmptyArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeModifyAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function unsafeModifyAt_<A>(as: ImmutableArray<A>, i: number, f: (a: A) => A): ImmutableArray<A>;
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeUpdateAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function unsafeUpdateAt_<A>(as: ImmutableArray<A>, i: number, a: A): ImmutableArray<A>;
+/**
+ * @tsplus getter fncts.ImmutableArray unzip
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function unzip<A, B>(self: ImmutableArray<readonly [A, B]>): readonly [ImmutableArray<A>, ImmutableArray<B>];
+/**
+ * @tsplus fluent fncts.ImmutableArray updateAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function updateAt_<A>(as: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableArray<A>>;
+export declare const wilt_: P.wilt_<ImmutableArrayF>;
+/**
+ * @tsplus pipeable fncts.ImmutableArray wilt_
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const wilt: P.wilt<ImmutableArrayF>;
+/**
+ * @tsplus fluent fncts.ImmutableArray wilt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const wiltSelf: P.wiltSelf<ImmutableArrayF>;
+export declare const wiltWithIndex_: P.wiltWithIndex_<ImmutableArrayF>;
+/**
+ * @tsplus dataFirst wiltWithIndex_
+ */
+export declare const wiltWithIndex: P.wiltWithIndex<ImmutableArrayF>;
+/**
+ * @tsplus getter fncts.ImmutableArray wiltWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const wiltWithIndexSelf: P.wiltWithIndexSelf<ImmutableArrayF>;
+export declare const wither_: P.wither_<ImmutableArrayF>;
+/**
+ * @tsplus dataFirst wither_
+ */
+export declare const wither: P.wither<ImmutableArrayF>;
+/**
+ * @tsplus fluent fncts.ImmutableArray wither
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const witherSelf: P.witherSelf<ImmutableArrayF>;
+export declare const witherWithIndex_: P.witherWithIndex_<ImmutableArrayF>;
+/**
+ * @tsplus dataFirst witherWithIndex_
+ */
+export declare const witherWithIndex: P.witherWithIndex<ImmutableArrayF>;
+/**
+ * @tsplus fluent fncts.ImmutableArray witherWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const witherWithIndexSelf: P.witherWithIndexSelf<ImmutableArrayF>;
+/**
+ * @tsplus fluent fncts.ImmutableArray zip
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function zip_<A, B>(self: ImmutableArray<A>, that: ImmutableArray<B>): ImmutableArray<readonly [A, B]>;
+/**
+ * @tsplus fluent fncts.ImmutableArray zipWith
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function zipWith_<A, B, C>(self: ImmutableArray<A>, fb: ImmutableArray<B>, f: (a: A, b: B) => C): ImmutableArray<C>;