effect 3.8.4 → 3.9.0

package/dist/dts/Chunk.d.ts

@@ -57,7 +57,19 @@ export declare const getEquivalence: <A>(isEquivalent: Equivalence.Equivalence<A
  * @since 2.0.0
  */
 export declare const isChunk: {
+    /**
+     * Checks if `u` is a `Chunk<unknown>`
+     *
+     * @category constructors
+     * @since 2.0.0
+     */
     <A>(u: Iterable<A>): u is Chunk<A>;
+    /**
+     * Checks if `u` is a `Chunk<unknown>`
+     *
+     * @category constructors
+     * @since 2.0.0
+     */
     (u: unknown): u is Chunk<unknown>;
 };
 /**
@@ -126,7 +138,19 @@ export declare const reverse: <S extends Chunk<any>>(self: S) => Chunk.With<S, C
  * @since 2.0.0
  */
 export declare const get: {
+    /**
+     * This function provides a safe way to read a value at a particular index from a `Chunk`.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     (index: number): <A>(self: Chunk<A>) => Option<A>;
+    /**
+     * This function provides a safe way to read a value at a particular index from a `Chunk`.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, index: number): Option<A>;
 };
 /**
@@ -150,7 +174,19 @@ export declare const unsafeFromNonEmptyArray: <A>(self: NonEmptyReadonlyArray<A>
  * @category unsafe
  */
 export declare const unsafeGet: {
+    /**
+     * Gets an element unsafely, will throw on out of bounds
+     *
+     * @since 2.0.0
+     * @category unsafe
+     */
     (index: number): <A>(self: Chunk<A>) => A;
+    /**
+     * Gets an element unsafely, will throw on out of bounds
+     *
+     * @since 2.0.0
+     * @category unsafe
+     */
     <A>(self: Chunk<A>, index: number): A;
 };
 /**
@@ -160,7 +196,19 @@ export declare const unsafeGet: {
  * @since 2.0.0
  */
 export declare const append: {
+    /**
+     * Appends the specified element to the end of the `Chunk`.
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A2>(a: A2): <A>(self: Chunk<A>) => NonEmptyChunk<A2 | A>;
+    /**
+     * Appends the specified element to the end of the `Chunk`.
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A, A2>(self: Chunk<A>, a: A2): NonEmptyChunk<A | A2>;
 };
 /**
@@ -170,7 +218,19 @@ export declare const append: {
  * @since 2.0.0
  */
 export declare const prepend: {
+    /**
+     * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`.
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <B>(elem: B): <A>(self: Chunk<A>) => NonEmptyChunk<B | A>;
+    /**
+     * Prepend an element to the front of a `Chunk`, creating a new `NonEmptyChunk`.
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, elem: B): NonEmptyChunk<A | B>;
 };
 /**
@@ -179,7 +239,17 @@ export declare const prepend: {
  * @since 2.0.0
  */
 export declare const take: {
+    /**
+     * Takes the first up to `n` elements from the chunk
+     *
+     * @since 2.0.0
+     */
     (n: number): <A>(self: Chunk<A>) => Chunk<A>;
+    /**
+     * Takes the first up to `n` elements from the chunk
+     *
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, n: number): Chunk<A>;
 };
 /**
@@ -188,7 +258,17 @@ export declare const take: {
  * @since 2.0.0
  */
 export declare const drop: {
+    /**
+     * Drops the first up to `n` elements from the chunk
+     *
+     * @since 2.0.0
+     */
     (n: number): <A>(self: Chunk<A>) => Chunk<A>;
+    /**
+     * Drops the first up to `n` elements from the chunk
+     *
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, n: number): Chunk<A>;
 };
 /**
@@ -197,7 +277,17 @@ export declare const drop: {
  * @since 2.0.0
  */
 export declare const dropRight: {
+    /**
+     * Drops the last `n` elements.
+     *
+     * @since 2.0.0
+     */
     (n: number): <A>(self: Chunk<A>) => Chunk<A>;
+    /**
+     * Drops the last `n` elements.
+     *
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, n: number): Chunk<A>;
 };
 /**
@@ -206,7 +296,17 @@ export declare const dropRight: {
  * @since 2.0.0
  */
 export declare const dropWhile: {
+    /**
+     * Drops all elements so long as the predicate returns true.
+     *
+     * @since 2.0.0
+     */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Chunk<A>;
+    /**
+     * Drops all elements so long as the predicate returns true.
+     *
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
 };
 /**
@@ -225,9 +325,69 @@ export declare const dropWhile: {
  * @since 2.0.0
  */
 export declare const prependAll: {
+    /**
+     * Prepends the specified prefix chunk to the beginning of the specified chunk.
+     * If either chunk is non-empty, the result is also a non-empty chunk.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray),
+     *   ["a", "b", 1, 2]
+     * )
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <S extends Chunk<any>, T extends Chunk<any>>(that: T): (self: S) => Chunk.OrNonEmpty<S, T, Chunk.Infer<S> | Chunk.Infer<T>>;
+    /**
+     * Prepends the specified prefix chunk to the beginning of the specified chunk.
+     * If either chunk is non-empty, the result is also a non-empty chunk.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray),
+     *   ["a", "b", 1, 2]
+     * )
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>;
+    /**
+     * Prepends the specified prefix chunk to the beginning of the specified chunk.
+     * If either chunk is non-empty, the result is also a non-empty chunk.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray),
+     *   ["a", "b", 1, 2]
+     * )
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>;
+    /**
+     * Prepends the specified prefix chunk to the beginning of the specified chunk.
+     * If either chunk is non-empty, the result is also a non-empty chunk.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.make(1, 2).pipe(Chunk.prependAll(Chunk.make("a", "b")), Chunk.toArray),
+     *   ["a", "b", 1, 2]
+     * )
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
 };
 /**
@@ -246,9 +406,69 @@ export declare const prependAll: {
  * @since 2.0.0
  */
 export declare const appendAll: {
+    /**
+     * Concatenates two chunks, combining their elements.
+     * If either chunk is non-empty, the result is also a non-empty chunk.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray),
+     *   [1, 2, "a", "b"]
+     * )
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <S extends Chunk<any>, T extends Chunk<any>>(that: T): (self: S) => Chunk.OrNonEmpty<S, T, Chunk.Infer<S> | Chunk.Infer<T>>;
+    /**
+     * Concatenates two chunks, combining their elements.
+     * If either chunk is non-empty, the result is also a non-empty chunk.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray),
+     *   [1, 2, "a", "b"]
+     * )
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>;
+    /**
+     * Concatenates two chunks, combining their elements.
+     * If either chunk is non-empty, the result is also a non-empty chunk.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray),
+     *   [1, 2, "a", "b"]
+     * )
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>;
+    /**
+     * Concatenates two chunks, combining their elements.
+     * If either chunk is non-empty, the result is also a non-empty chunk.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.make(1, 2).pipe(Chunk.appendAll(Chunk.make("a", "b")), Chunk.toArray),
+     *   [1, 2, "a", "b"]
+     * )
+     *
+     * @category concatenating
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
 };
 /**
@@ -258,7 +478,19 @@ export declare const appendAll: {
  * @category filtering
  */
 export declare const filterMap: {
+    /**
+     * Returns a filtered and mapped subset of the elements.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B>(f: (a: A, i: number) => Option<B>): (self: Chunk<A>) => Chunk<B>;
+    /**
+     * Returns a filtered and mapped subset of the elements.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B>(self: Chunk<A>, f: (a: A, i: number) => Option<B>): Chunk<B>;
 };
 /**
@@ -268,9 +500,33 @@ export declare const filterMap: {
  * @category filtering
  */
 export declare const filter: {
+    /**
+     * Returns a filtered and mapped subset of the elements.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Chunk<B>;
+    /**
+     * Returns a filtered and mapped subset of the elements.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Chunk<A>;
+    /**
+     * Returns a filtered and mapped subset of the elements.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>;
+    /**
+     * Returns a filtered and mapped subset of the elements.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
 };
 /**
@@ -280,7 +536,19 @@ export declare const filter: {
  * @category filtering
  */
 export declare const filterMapWhile: {
+    /**
+     * Transforms all elements of the chunk for as long as the specified function returns some value
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B>(f: (a: A) => Option<B>): (self: Chunk<A>) => Chunk<B>;
+    /**
+     * Transforms all elements of the chunk for as long as the specified function returns some value
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B>(self: Chunk<A>, f: (a: A) => Option<B>): Chunk<B>;
 };
 /**
@@ -297,8 +565,26 @@ export declare const compact: <A>(self: Chunk<Option<A>>) => Chunk<A>;
  * @category sequencing
  */
 export declare const flatMap: {
+    /**
+     * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <S extends Chunk<any>, T extends Chunk<any>>(f: (a: Chunk.Infer<S>, i: number) => T): (self: S) => Chunk.AndNonEmpty<S, T, Chunk.Infer<T>>;
+    /**
+     * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => NonEmptyChunk<B>): NonEmptyChunk<B>;
+    /**
+     * Applies a function to each element in a chunk and returns a new chunk containing the concatenated mapped elements.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <A, B>(self: Chunk<A>, f: (a: A, i: number) => Chunk<B>): Chunk<B>;
 };
 /**
@@ -308,7 +594,19 @@ export declare const flatMap: {
  * @category combinators
  */
 export declare const forEach: {
+    /**
+     * Applies the specified function to each element of the `List`.
+     *
+     * @since 2.0.0
+     * @category combinators
+     */
     <A, B>(f: (a: A) => B): (self: Chunk<A>) => void;
+    /**
+     * Applies the specified function to each element of the `List`.
+     *
+     * @since 2.0.0
+     * @category combinators
+     */
     <A, B>(self: Chunk<A>, f: (a: A) => B): void;
 };
 /**
@@ -325,7 +623,19 @@ export declare const flatten: <S extends Chunk<Chunk<any>>>(self: S) => Chunk.Fl
  * @category elements
  */
 export declare const chunksOf: {
+    /**
+     * Groups elements in chunks of up to `n` elements.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     (n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>;
+    /**
+     * Groups elements in chunks of up to `n` elements.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>;
 };
 /**
@@ -337,7 +647,23 @@ export declare const chunksOf: {
  * @category elements
  */
 export declare const intersection: {
+    /**
+     * Creates a Chunk of unique values that are included in all given Chunks.
+     *
+     * The order and references of result values are determined by the Chunk.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A & B>;
+    /**
+     * Creates a Chunk of unique values that are included in all given Chunks.
+     *
+     * The order and references of result values are determined by the Chunk.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A & B>;
 };
 /**
@@ -441,8 +767,53 @@ export declare namespace Chunk {
  * @category mapping
  */
 export declare const map: {
+    /**
+     * Transforms the elements of a chunk using the specified mapping function.
+     * If the input chunk is non-empty, the resulting chunk will also be non-empty.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.map(Chunk.make(1, 2), (n) => n + 1),
+     *   Chunk.make(2, 3)
+     * )
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <S extends Chunk<any>, B>(f: (a: Chunk.Infer<S>, i: number) => B): (self: S) => Chunk.With<S, B>;
+    /**
+     * Transforms the elements of a chunk using the specified mapping function.
+     * If the input chunk is non-empty, the resulting chunk will also be non-empty.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.map(Chunk.make(1, 2), (n) => n + 1),
+     *   Chunk.make(2, 3)
+     * )
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, B>(self: NonEmptyChunk<A>, f: (a: A, i: number) => B): NonEmptyChunk<B>;
+    /**
+     * Transforms the elements of a chunk using the specified mapping function.
+     * If the input chunk is non-empty, the resulting chunk will also be non-empty.
+     *
+     * @example
+     * import { Chunk } from "effect"
+     *
+     * assert.deepStrictEqual(
+     *   Chunk.map(Chunk.make(1, 2), (n) => n + 1),
+     *   Chunk.make(2, 3)
+     * )
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, B>(self: Chunk<A>, f: (a: A, i: number) => B): Chunk<B>;
 };
 /**
@@ -452,7 +823,19 @@ export declare const map: {
  * @category folding
  */
 export declare const mapAccum: {
+    /**
+     * Statefully maps over the chunk, producing new elements of type `B`.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
     <S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Chunk<A>) => [S, Chunk<B>];
+    /**
+     * Statefully maps over the chunk, producing new elements of type `B`.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
     <S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]): [S, Chunk<B>];
 };
 /**
@@ -462,9 +845,33 @@ export declare const mapAccum: {
  * @since 2.0.0
  */
 export declare const partition: {
+    /**
+     * Separate elements based on a predicate that also exposes the index of the element.
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <A, B extends A>(refinement: (a: NoInfer<A>, i: number) => a is B): (self: Chunk<A>) => [excluded: Chunk<Exclude<A, B>>, satisfying: Chunk<B>];
+    /**
+     * Separate elements based on a predicate that also exposes the index of the element.
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <A>(predicate: (a: NoInfer<A>, i: number) => boolean): (self: Chunk<A>) => [excluded: Chunk<A>, satisfying: Chunk<A>];
+    /**
+     * Separate elements based on a predicate that also exposes the index of the element.
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <A, B extends A>(self: Chunk<A>, refinement: (a: A, i: number) => a is B): [excluded: Chunk<Exclude<A, B>>, satisfying: Chunk<B>];
+    /**
+     * Separate elements based on a predicate that also exposes the index of the element.
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: (a: A, i: number) => boolean): [excluded: Chunk<A>, satisfying: Chunk<A>];
 };
 /**
@@ -474,7 +881,19 @@ export declare const partition: {
  * @since 2.0.0
  */
 export declare const partitionMap: {
+    /**
+     * Partitions the elements of this chunk into two chunks using f.
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <A, B, C>(f: (a: A) => Either<C, B>): (self: Chunk<A>) => [left: Chunk<B>, right: Chunk<C>];
+    /**
+     * Partitions the elements of this chunk into two chunks using f.
+     *
+     * @category filtering
+     * @since 2.0.0
+     */
     <A, B, C>(self: Chunk<A>, f: (a: A) => Either<C, B>): [left: Chunk<B>, right: Chunk<C>];
 };
 /**
@@ -498,7 +917,19 @@ export declare const size: <A>(self: Chunk<A>) => number;
  * @category sorting
  */
 export declare const sort: {
+    /**
+     * Sort the elements of a Chunk in increasing order, creating a new Chunk.
+     *
+     * @since 2.0.0
+     * @category sorting
+     */
     <B>(O: Order.Order<B>): <A extends B>(self: Chunk<A>) => Chunk<A>;
+    /**
+     * Sort the elements of a Chunk in increasing order, creating a new Chunk.
+     *
+     * @since 2.0.0
+     * @category sorting
+     */
     <A extends B, B>(self: Chunk<A>, O: Order.Order<B>): Chunk<A>;
 };
 /**
@@ -506,7 +937,15 @@ export declare const sort: {
  * @category sorting
  */
 export declare const sortWith: {
+    /**
+     * @since 2.0.0
+     * @category sorting
+     */
     <A, B>(f: (a: A) => B, order: Order.Order<B>): (self: Chunk<A>) => Chunk<A>;
+    /**
+     * @since 2.0.0
+     * @category sorting
+     */
     <A, B>(self: Chunk<A>, f: (a: A) => B, order: Order.Order<B>): Chunk<A>;
 };
 /**
@@ -516,7 +955,19 @@ export declare const sortWith: {
  * @category splitting
  */
 export declare const splitAt: {
+    /**
+     *  Returns two splits of this chunk at the specified index.
+     *
+     * @since 2.0.0
+     * @category splitting
+     */
     (n: number): <A>(self: Chunk<A>) => [beforeIndex: Chunk<A>, fromIndex: Chunk<A>];
+    /**
+     *  Returns two splits of this chunk at the specified index.
+     *
+     * @since 2.0.0
+     * @category splitting
+     */
     <A>(self: Chunk<A>, n: number): [beforeIndex: Chunk<A>, fromIndex: Chunk<A>];
 };
 /**
@@ -527,7 +978,21 @@ export declare const splitAt: {
  * @since 2.0.0
  */
 export declare const splitNonEmptyAt: {
+    /**
+     * Splits a `NonEmptyChunk` into two segments, with the first segment containing a maximum of `n` elements.
+     * The value of `n` must be `>= 1`.
+     *
+     * @category splitting
+     * @since 2.0.0
+     */
     (n: number): <A>(self: NonEmptyChunk<A>) => [beforeIndex: NonEmptyChunk<A>, fromIndex: Chunk<A>];
+    /**
+     * Splits a `NonEmptyChunk` into two segments, with the first segment containing a maximum of `n` elements.
+     * The value of `n` must be `>= 1`.
+     *
+     * @category splitting
+     * @since 2.0.0
+     */
     <A>(self: NonEmptyChunk<A>, n: number): [beforeIndex: NonEmptyChunk<A>, fromIndex: Chunk<A>];
 };
 /**
@@ -537,7 +1002,19 @@ export declare const splitNonEmptyAt: {
  * @category splitting
  */
 export declare const split: {
+    /**
+     * Splits this chunk into `n` equally sized chunks.
+     *
+     * @since 2.0.0
+     * @category splitting
+     */
     (n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>;
+    /**
+     * Splits this chunk into `n` equally sized chunks.
+     *
+     * @since 2.0.0
+     * @category splitting
+     */
     <A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>;
 };
 /**
@@ -548,7 +1025,21 @@ export declare const split: {
  * @since 2.0.0
  */
 export declare const splitWhere: {
+    /**
+     * Splits this chunk on the first element that matches this predicate.
+     * Returns a tuple containing two chunks: the first one is before the match, and the second one is from the match onward.
+     *
+     * @category splitting
+     * @since 2.0.0
+     */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => [beforeMatch: Chunk<A>, fromMatch: Chunk<A>];
+    /**
+     * Splits this chunk on the first element that matches this predicate.
+     * Returns a tuple containing two chunks: the first one is before the match, and the second one is from the match onward.
+     *
+     * @category splitting
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): [beforeMatch: Chunk<A>, fromMatch: Chunk<A>];
 };
 /**
@@ -572,7 +1063,19 @@ export declare const tailNonEmpty: <A>(self: NonEmptyChunk<A>) => Chunk<A>;
  * @category elements
  */
 export declare const takeRight: {
+    /**
+     * Takes the last `n` elements.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     (n: number): <A>(self: Chunk<A>) => Chunk<A>;
+    /**
+     * Takes the last `n` elements.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A>(self: Chunk<A>, n: number): Chunk<A>;
 };
 /**
@@ -582,9 +1085,33 @@ export declare const takeRight: {
  * @category elements
  */
 export declare const takeWhile: {
+    /**
+     * Takes all elements so long as the predicate returns true.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Chunk<B>;
+    /**
+     * Takes all elements so long as the predicate returns true.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Chunk<A>;
+    /**
+     * Takes all elements so long as the predicate returns true.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Chunk<B>;
+    /**
+     * Takes all elements so long as the predicate returns true.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Chunk<A>;
 };
 /**
@@ -594,7 +1121,19 @@ export declare const takeWhile: {
  * @category elements
  */
 export declare const union: {
+    /**
+     * Creates a Chunks of unique values, in order, from all given Chunks.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>;
+    /**
+     * Creates a Chunks of unique values, in order, from all given Chunks.
+     *
+     * @since 2.0.0
+     * @category elements
+     */
     <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
 };
 /**
@@ -627,7 +1166,19 @@ export declare const unzip: <A, B>(self: Chunk<readonly [A, B]>) => [Chunk<A>, C
  * @category zipping
  */
 export declare const zipWith: {
+    /**
+     * Zips this chunk pointwise with the specified chunk using the specified combiner.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>;
+    /**
+     * Zips this chunk pointwise with the specified chunk using the specified combiner.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C): Chunk<C>;
 };
 /**
@@ -637,7 +1188,19 @@ export declare const zipWith: {
  * @category zipping
  */
 export declare const zip: {
+    /**
+     * Zips this chunk pointwise with the specified chunk.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<[A, B]>;
+    /**
+     * Zips this chunk pointwise with the specified chunk.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<[A, B]>;
 };
 /**
@@ -647,14 +1210,32 @@ export declare const zip: {
  * @since 2.0.0
  */
 export declare const remove: {
+    /**
+     * Delete the element at the specified index, creating a new `Chunk`,
+     * or returning the input if the index is out of bounds.
+     *
+     * @since 2.0.0
+     */
     (i: number): <A>(self: Chunk<A>) => Chunk<A>;
+    /**
+     * Delete the element at the specified index, creating a new `Chunk`,
+     * or returning the input if the index is out of bounds.
+     *
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, i: number): Chunk<A>;
 };
 /**
  * @since 2.0.0
  */
 export declare const modifyOption: {
+    /**
+     * @since 2.0.0
+     */
     <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Option<Chunk<A | B>>;
+    /**
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>>;
 };
 /**
@@ -664,7 +1245,19 @@ export declare const modifyOption: {
  * @since 2.0.0
  */
 export declare const modify: {
+    /**
+     * Apply a function to the element at the specified index, creating a new `Chunk`,
+     * or returning the input if the index is out of bounds.
+     *
+     * @since 2.0.0
+     */
     <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Chunk<A | B>;
+    /**
+     * Apply a function to the element at the specified index, creating a new `Chunk`,
+     * or returning the input if the index is out of bounds.
+     *
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Chunk<A | B>;
 };
 /**
@@ -674,14 +1267,32 @@ export declare const modify: {
  * @since 2.0.0
  */
 export declare const replace: {
+    /**
+     * Change the element at the specified index, creating a new `Chunk`,
+     * or returning the input if the index is out of bounds.
+     *
+     * @since 2.0.0
+     */
     <B>(i: number, b: B): <A>(self: Chunk<A>) => Chunk<B | A>;
+    /**
+     * Change the element at the specified index, creating a new `Chunk`,
+     * or returning the input if the index is out of bounds.
+     *
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, i: number, b: B): Chunk<B | A>;
 };
 /**
  * @since 2.0.0
  */
 export declare const replaceOption: {
+    /**
+     * @since 2.0.0
+     */
     <B>(i: number, b: B): <A>(self: Chunk<A>) => Option<Chunk<B | A>>;
+    /**
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, i: number, b: B): Option<Chunk<B | A>>;
 };
 /**
@@ -693,7 +1304,23 @@ export declare const replaceOption: {
  * @since 2.0.0
  */
 export declare const makeBy: {
+    /**
+     * Return a Chunk of length n with element i initialized with f(i).
+     *
+     * **Note**. `n` is normalized to an integer >= 1.
+     *
+     * @category constructors
+     * @since 2.0.0
+     */
     <A>(f: (i: number) => A): (n: number) => NonEmptyChunk<A>;
+    /**
+     * Return a Chunk of length n with element i initialized with f(i).
+     *
+     * **Note**. `n` is normalized to an integer >= 1.
+     *
+     * @category constructors
+     * @since 2.0.0
+     */
     <A>(n: number, f: (i: number) => A): NonEmptyChunk<A>;
 };
 /**
@@ -710,7 +1337,19 @@ export declare const range: (start: number, end: number) => NonEmptyChunk<number
  * @since 2.0.0
  */
 export declare const contains: {
+    /**
+     * Returns a function that checks if a `Chunk` contains a given value using the default `Equivalence`.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(a: A): (self: Chunk<A>) => boolean;
+    /**
+     * Returns a function that checks if a `Chunk` contains a given value using the default `Equivalence`.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, a: A): boolean;
 };
 /**
@@ -731,9 +1370,37 @@ export declare const containsWith: <A>(isEquivalent: (self: A, that: A) => boole
  * @since 2.0.0
  */
 export declare const findFirst: {
+    /**
+     * Returns the first element that satisfies the specified
+     * predicate, or `None` if no such element exists.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Option<B>;
+    /**
+     * Returns the first element that satisfies the specified
+     * predicate, or `None` if no such element exists.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Option<A>;
+    /**
+     * Returns the first element that satisfies the specified
+     * predicate, or `None` if no such element exists.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>;
+    /**
+     * Returns the first element that satisfies the specified
+     * predicate, or `None` if no such element exists.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>;
 };
 /**
@@ -743,7 +1410,19 @@ export declare const findFirst: {
  * @since 2.0.0
  */
 export declare const findFirstIndex: {
+    /**
+     * Return the first index for which a predicate holds.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(predicate: Predicate<A>): (self: Chunk<A>) => Option<number>;
+    /**
+     * Return the first index for which a predicate holds.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Option<number>;
 };
 /**
@@ -753,9 +1432,33 @@ export declare const findFirstIndex: {
  * @since 2.0.0
  */
 export declare const findLast: {
+    /**
+     * Find the last element for which a predicate holds.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => Option<B>;
+    /**
+     * Find the last element for which a predicate holds.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => Option<A>;
+    /**
+     * Find the last element for which a predicate holds.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>;
+    /**
+     * Find the last element for which a predicate holds.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>;
 };
 /**
@@ -765,7 +1468,19 @@ export declare const findLast: {
  * @since 2.0.0
  */
 export declare const findLastIndex: {
+    /**
+     * Return the last index for which a predicate holds.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(predicate: Predicate<A>): (self: Chunk<A>) => Option<number>;
+    /**
+     * Return the last index for which a predicate holds.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): Option<number>;
 };
 /**
@@ -775,9 +1490,33 @@ export declare const findLastIndex: {
  * @since 2.0.0
  */
 export declare const every: {
+    /**
+     * Check if a predicate holds true for every `Chunk` element.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): (self: Chunk<A>) => self is Chunk<B>;
+    /**
+     * Check if a predicate holds true for every `Chunk` element.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(predicate: Predicate<A>): (self: Chunk<A>) => boolean;
+    /**
+     * Check if a predicate holds true for every `Chunk` element.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): self is Chunk<B>;
+    /**
+     * Check if a predicate holds true for every `Chunk` element.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): boolean;
 };
 /**
@@ -787,7 +1526,19 @@ export declare const every: {
  * @since 2.0.0
  */
 export declare const some: {
+    /**
+     * Check if a predicate holds true for some `Chunk` element.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(predicate: Predicate<NoInfer<A>>): (self: Chunk<A>) => self is NonEmptyChunk<A>;
+    /**
+     * Check if a predicate holds true for some `Chunk` element.
+     *
+     * @category elements
+     * @since 2.0.0
+     */
     <A>(self: Chunk<A>, predicate: Predicate<A>): self is NonEmptyChunk<A>;
 };
 /**
@@ -797,7 +1548,19 @@ export declare const some: {
  * @since 2.0.0
  */
 export declare const join: {
+    /**
+     * Joins the elements together with "sep" in the middle.
+     *
+     * @category folding
+     * @since 2.0.0
+     */
     (sep: string): (self: Chunk<string>) => string;
+    /**
+     * Joins the elements together with "sep" in the middle.
+     *
+     * @category folding
+     * @since 2.0.0
+     */
     (self: Chunk<string>, sep: string): string;
 };
 /**
@@ -805,7 +1568,15 @@ export declare const join: {
  * @since 2.0.0
  */
 export declare const reduce: {
+    /**
+     * @category folding
+     * @since 2.0.0
+     */
     <B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B;
+    /**
+     * @category folding
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B;
 };
 /**
@@ -813,7 +1584,15 @@ export declare const reduce: {
  * @since 2.0.0
  */
 export declare const reduceRight: {
+    /**
+     * @category folding
+     * @since 2.0.0
+     */
     <B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B;
+    /**
+     * @category folding
+     * @since 2.0.0
+     */
     <A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B;
 };
 /**
@@ -833,7 +1612,19 @@ export declare const differenceWith: <A>(isEquivalent: (self: A, that: A) => boo
  * @since 3.2.0
  */
 export declare const difference: {
+    /**
+     * Creates a `Chunk` of values not included in the other given `Chunk`.
+     * The order and references of result values are determined by the first `Chunk`.
+     *
+     * @since 3.2.0
+     */
     <A>(that: Chunk<A>): (self: Chunk<A>) => Chunk<A>;
+    /**
+     * Creates a `Chunk` of values not included in the other given `Chunk`.
+     * The order and references of result values are determined by the first `Chunk`.
+     *
+     * @since 3.2.0
+     */
     <A>(self: Chunk<A>, that: Chunk<A>): Chunk<A>;
 };
 export {};