/**
 * @since 1.0.0
 */
import type { Either } from "@fp-ts/core/Either";
import type { TypeLambda } from "@fp-ts/core/HKT";
import type { Option } from "@fp-ts/core/Option";
import type { Predicate, Refinement } from "@fp-ts/core/Predicate";
import type { Order } from "@fp-ts/core/typeclass/Order";
import * as Equal from "@fp-ts/data/Equal";
import type { NonEmptyIterable } from "@fp-ts/data/NonEmpty";
declare const TypeId: unique symbol;
/**
 * @since 1.0.0
 * @category symbol
 */
export type TypeId = typeof TypeId;
/**
 * @category model
 * @since 1.0.0
 */
export interface NonEmptyChunk<A> extends Chunk<A>, NonEmptyIterable<A> {
}
/**
 * @since 1.0.0
 * @category models
 */
export interface Chunk<A> extends Iterable<A>, Equal.Equal {
    readonly _id: TypeId;
    readonly length: number;
    get array(): ReadonlyArray<A>;
    /**
     * @since 1.0.0
     */
    toReadonlyArray(this: Chunk<A>): ReadonlyArray<A>;
    /**
     * @since 1.0.0
     */
    isNonEmpty(this: Chunk<A>): this is NonEmptyChunk<A>;
    /**
     * @since 1.0.0
     */
    isEmpty(this: Chunk<A>): boolean;
    /**
     * @since 1.0.0
     */
    map<B>(this: Chunk<A>, f: (a: A) => B): Chunk<B>;
    /**
     * @since 1.0.0
     */
    flatMap<B>(this: Chunk<A>, f: (a: A) => Chunk<B>): Chunk<B>;
    /**
     * @since 1.0.0
     */
    forEach(this: Chunk<A>, f: (a: A) => void): void;
    /**
     * @since 1.0.0
     */
    append<B>(this: Chunk<A>, b: B): Chunk<A | B>;
    /**
     * @since 1.0.0
     */
    prepend<B>(this: Chunk<A>, b: B): Chunk<A | B>;
    /**
     * @since 1.0.0
     */
    concat<B>(this: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
    /**
     * @since 1.0.0
     */
    get(this: Chunk<A>, index: number): Option<A>;
    /**
     * @since 1.0.0
     */
    unsafeGet(this: Chunk<A>, index: number): A;
}
/**
 * @since 1.0.0
 * @category type lambdas
 */
export interface ChunkTypeLambda extends TypeLambda {
    readonly type: Chunk<this["Target"]>;
}
/**
 * Checks if `u` is a `Chunk<unknown>`
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const isChunk: {
    <A>(u: Iterable<A>): u is Chunk<A>;
    (u: unknown): u is Chunk<unknown>;
};
/**
 * @since 1.0.0
 * @category constructors
 */
export declare const empty: <A = never>() => Chunk<A>;
/**
 * Converts from an `Iterable<A>`
 *
 * @since 1.0.0
 * @category conversions
 */
export declare const fromIterable: <A>(self: Iterable<A>) => Chunk<A>;
/**
 * Converts to a `ReadonlyArray<A>`
 *
 * @since 1.0.0
 * @category conversions
 */
export declare const toReadonlyArray: <A>(self: Chunk<A>) => readonly A[];
/**
 * This function provides a safe way to read a value at a particular index from a `Chunk`.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const get: (<A>(self: Chunk<A>, index: number) => Option<A>) & ((index: number) => <A_1>(self: Chunk<A_1>) => Option<A_1>);
/**
 * Wraps an array into a chunk without copying, unsafe on mutable arrays
 *
 * @since 1.0.0
 * @category unsafe
 */
export declare const unsafeFromArray: <A>(self: readonly A[]) => Chunk<A>;
/**
 * Gets an element unsafely, will throw on out of bounds
 *
 * @since 1.0.0
 * @category unsafe
 */
export declare const unsafeGet: (<A>(self: Chunk<A>, index: number) => A) & ((index: number) => <A_1>(self: Chunk<A_1>) => A_1);
/**
 * Appends the value to the chunk
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const append: (<A, A2>(self: Chunk<A>, a: A2) => Chunk<A | A2>) & (<A2_1>(a: A2_1) => <A_1>(self: Chunk<A_1>) => Chunk<A2_1 | A_1>);
/**
 * Prepends the value to the chunk
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const prepend: (<A, B>(self: Chunk<A>, elem: B) => Chunk<A | B>) & (<B_1>(elem: B_1) => <A_1>(self: Chunk<A_1>) => Chunk<B_1 | A_1>);
/**
 * Takes the first up to `n` elements from the chunk
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const take: (<A>(self: Chunk<A>, n: number) => Chunk<A>) & ((n: number) => <A_1>(self: Chunk<A_1>) => Chunk<A_1>);
/**
 * Drops the first up to `n` elements from the chunk
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const drop: (<A>(self: Chunk<A>, n: number) => Chunk<A>) & ((n: number) => <A_1>(self: Chunk<A_1>) => Chunk<A_1>);
/**
 * Drops the last `n` elements.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const dropRight: (<A>(self: Chunk<A>, n: number) => Chunk<A>) & ((n: number) => <A_1>(self: Chunk<A_1>) => Chunk<A_1>);
/**
 * Drops all elements so long as the predicate returns true.
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const dropWhile: (<A>(self: Chunk<A>, f: (a: A) => boolean) => Chunk<A>) & (<A_1>(f: (a: A_1) => boolean) => (self: Chunk<A_1>) => Chunk<A_1>);
/**
 * @category mutations
 * @since 1.0.0
 */
export declare const prependAllNonEmpty: {
    <A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>;
    <A_1, B_1>(self: NonEmptyChunk<A_1>, that: Chunk<B_1>): NonEmptyChunk<A_1 | B_1>;
} & {
    <B_2>(that: NonEmptyChunk<B_2>): <A_2>(self: Chunk<A_2>) => NonEmptyChunk<B_2 | A_2>;
    <B_3>(that: Chunk<B_3>): <A_3>(self: NonEmptyChunk<A_3>) => NonEmptyChunk<B_3 | A_3>;
};
/**
 * Concatenates the two chunks
 *
 * @since 1.0.0
 * @category mutations
 */
export declare const concat: (<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A | B>) & (<B_1>(that: Chunk<B_1>) => <A_1>(self: Chunk<A_1>) => Chunk<B_1 | A_1>);
/**
 * Compares the two chunks of equal length using the specified function
 *
 * @since 1.0.0
 * @category elements
 */
export declare const correspondsTo: (<A, B>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => boolean) => boolean) & (<A_1, B_1>(that: Chunk<B_1>, f: (a: A_1, b: B_1) => boolean) => (self: Chunk<A_1>) => boolean);
/**
 * Returns a filtered and mapped subset of the elements.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filterMap: (<A, B>(self: Iterable<A>, f: (a: A) => Option<B>) => Chunk<B>) & (<A_1, B_1>(f: (a: A_1) => Option<B_1>) => (self: Iterable<A_1>) => Chunk<B_1>);
/**
 * Returns a filtered and mapped subset of the elements.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filter: {
    <C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): Chunk<B>;
    <B_1 extends A_1, A_1 = B_1>(self: Chunk<B_1>, predicate: Predicate<A_1>): Chunk<B_1>;
} & {
    <C_1 extends A_2, B_2 extends A_2, A_2 = C_1>(refinement: Refinement<A_2, B_2>): (self: Chunk<C_1>) => Chunk<B_2>;
    <B_3 extends A_3, A_3 = B_3>(predicate: Predicate<A_3>): (self: Chunk<B_3>) => Chunk<B_3>;
};
/**
 * Returns a filtered and mapped subset of the elements.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filterMapWithIndex: (<A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>) => Chunk<B>) & (<A_1, B_1>(f: (a: A_1, i: number) => Option<B_1>) => (self: Iterable<A_1>) => Chunk<B_1>);
/**
 * Transforms all elements of the chunk for as long as the specified function returns some value
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const filterMapWhile: (<A, B>(self: Iterable<A>, f: (a: A) => Option<B>) => Chunk<B>) & (<A_1, B_1>(f: (a: A_1) => Option<B_1>) => (self: Iterable<A_1>) => Chunk<B_1>);
/**
 * Tests whether a value is a member of a `Chunk<A>`.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const elem: (<A, B>(self: Chunk<A>, b: B) => boolean) & (<B_1>(b: B_1) => <A_1>(self: Chunk<A_1>) => boolean);
/**
 * Filter out optional values
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const compact: <A>(self: Iterable<Option<A>>) => Chunk<A>;
/**
 * Deduplicates adjacent elements that are identical.
 *
 * @since 1.0.0
 * @category filtering
 */
export declare const dedupeAdjacent: <A>(self: Chunk<A>) => Chunk<A>;
/**
 * Check if a predicate holds true for any `Chunk` member.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const some: (<A>(self: Chunk<A>, f: Predicate<A>) => boolean) & (<A_1>(f: Predicate<A_1>) => (self: Chunk<A_1>) => boolean);
/**
 * Check if a predicate holds true for every `Chunk` member.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const every: (<A>(self: Chunk<A>, f: Predicate<A>) => boolean) & (<A_1>(f: Predicate<A_1>) => (self: Chunk<A_1>) => boolean);
/**
 * Find the first element which satisfies a predicate (or a refinement) function.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const findFirst: {
    <A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>;
    <A_1>(self: Chunk<A_1>, predicate: Predicate<A_1>): Option<A_1>;
} & {
    <A_2, B_1 extends A_2>(refinement: Refinement<A_2, B_1>): (self: Chunk<A_2>) => Option<B_1>;
    <A_3>(predicate: Predicate<A_3>): (self: Chunk<A_3>) => Option<A_3>;
};
/**
 * Find the first index for which a predicate holds
 *
 * @since 1.0.0
 * @category elements
 */
export declare const findFirstIndex: (<A>(self: Chunk<A>, f: Predicate<A>) => Option<number>) & (<A_1>(f: Predicate<A_1>) => (self: Chunk<A_1>) => Option<number>);
/**
 * Find the first index for which a predicate holds
 *
 * @since 1.0.0
 * @category elements
 */
export declare const findLastIndex: (<A>(self: Chunk<A>, f: Predicate<A>) => Option<number>) & (<A_1>(f: Predicate<A_1>) => (self: Chunk<A_1>) => Option<number>);
/**
 * Find the last element which satisfies a predicate function
 *
 * @since 1.0.0
 * @category elements
 */
export declare const findLast: {
    <A, B extends A>(self: Chunk<A>, f: Refinement<A, B>): Option<B>;
    <A_1>(self: Chunk<A_1>, f: Predicate<A_1>): Option<A_1>;
} & {
    <A_2, B_1 extends A_2>(f: Refinement<A_2, B_1>): (self: Chunk<A_2>) => Option<B_1>;
    <A_3>(f: Predicate<A_3>): (self: Chunk<A_3>) => Option<A_3>;
};
/**
 * Returns a chunk with the elements mapped by the specified function.
 *
 * @since 1.0.0
 * @category sequencing
 */
export declare const flatMap: (<A, B>(self: Chunk<A>, f: (a: A) => Chunk<B>) => Chunk<B>) & (<A_1, B_1>(f: (a: A_1) => Chunk<B_1>) => (self: Chunk<A_1>) => Chunk<B_1>);
/**
 * Flattens a chunk of chunks into a single chunk by concatenating all chunks.
 *
 * @since 1.0.0
 * @category sequencing
 */
export declare const flatten: <A>(self: Chunk<Chunk<A>>) => Chunk<A>;
/**
 * Iterate over the chunk applying `f`.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const forEach: (<A>(self: Chunk<A>, f: (a: A) => void) => void) & (<A_1>(f: (a: A_1) => void) => (self: Chunk<A_1>) => void);
/**
 * Groups elements in chunks of up to `n` elements.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const chunksOf: (<A>(self: Chunk<A>, n: number) => Chunk<Chunk<A>>) & ((n: number) => <A_1>(self: Chunk<A_1>) => Chunk<Chunk<A_1>>);
/**
 * Returns the first element of this chunk if it exists.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const head: <A>(self: Chunk<A>) => Option<A>;
/**
 * 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 1.0.0
 * @category elements
 */
export declare const intersection: (<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A & B>) & (<A_1>(that: Chunk<A_1>) => <B_1>(self: Chunk<B_1>) => Chunk<A_1 & B_1>);
/**
 * Determines if the chunk is empty.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const isEmpty: <A>(self: Chunk<A>) => boolean;
/**
 * Determines if the chunk is not empty.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const isNonEmpty: <A>(self: Chunk<A>) => self is NonEmptyChunk<A>;
/**
 * Folds over the elements in this chunk from the left.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const reduce: (<A, B>(self: Chunk<A>, b: B, f: (s: B, a: A) => B) => B) & (<A_1, B_1>(b: B_1, f: (s: B_1, a: A_1) => B_1) => (self: Chunk<A_1>) => B_1);
/**
 * Folds over the elements in this chunk from the left.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const reduceWithIndex: (<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B) => B) & (<B_1, A_1>(b: B_1, f: (b: B_1, a: A_1, i: number) => B_1) => (self: Chunk<A_1>) => B_1);
/**
 * Folds over the elements in this chunk from the right.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const reduceRight: (<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A) => B) => B) & (<B_1, A_1>(b: B_1, f: (b: B_1, a: A_1) => B_1) => (self: Chunk<A_1>) => B_1);
/**
 * Folds over the elements in this chunk from the right.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const reduceRightWithIndex: (<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B) => B) & (<B_1, A_1>(b: B_1, f: (b: B_1, a: A_1, i: number) => B_1) => (self: Chunk<A_1>) => B_1);
/**
 * Joins the elements together with "sep" in the middle.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const join: ((self: Chunk<string>, sep: string) => string) & ((sep: string) => (self: Chunk<string>) => string);
/**
 * Returns the last element of this chunk if it exists.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const last: <A>(self: Chunk<A>) => Option<A>;
/**
 * Builds a `NonEmptyChunk` from an non-empty collection of elements.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const make: <As extends readonly [any, ...any[]]>(...as: As) => NonEmptyChunk<As[number]>;
/**
 * Builds a `NonEmptyChunk` from a single element.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const of: <A>(a: A) => NonEmptyChunk<A>;
/**
 * Return a Chunk of length n with element i initialized with f(i).
 *
 * **Note**. `n` is normalized to an integer >= 1.
 *
 * @since 1.0.0
 * @category constructors
 */
export declare const makeBy: (<A>(n: number, f: (i: number) => A) => NonEmptyChunk<A>) & (<A_1>(f: (i: number) => A_1) => (n: number) => NonEmptyChunk<A_1>);
/**
 * Returns an effect whose success is mapped by the specified f function.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const map: (<A, B>(self: Chunk<A>, f: (a: A) => B) => Chunk<B>) & (<A_1, B_1>(f: (a: A_1) => B_1) => (self: Chunk<A_1>) => Chunk<B_1>);
/**
 * Returns an effect whose success is mapped by the specified f function.
 *
 * @since 1.0.0
 * @category mapping
 */
export declare const mapWithIndex: (<A, B>(self: Chunk<A>, f: (a: A, i: number) => B) => Chunk<B>) & (<A_1, B_1>(f: (a: A_1, i: number) => B_1) => (self: Chunk<A_1>) => Chunk<B_1>);
/**
 * Statefully maps over the chunk, producing new elements of type `B`.
 *
 * @since 1.0.0
 * @category folding
 */
export declare const mapAccum: (<S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]) => readonly [S, Chunk<B>]) & (<S_1, A_1, B_1>(s: S_1, f: (s: S_1, a: A_1) => readonly [S_1, B_1]) => (self: Chunk<A_1>) => readonly [S_1, Chunk<B_1>]);
/**
 * Separate elements based on a predicate that also exposes the index of the element.
 *
 * @category filtering
 * @since 1.0.0
 */
export declare const partitionWithIndex: {
    <C extends A, B extends A, A = C>(self: Chunk<C>, refinement: (a: A, i: number) => a is B): readonly [Chunk<C>, Chunk<B>];
    <B_1 extends A_1, A_1 = B_1>(self: Chunk<B_1>, predicate: (a: A_1, i: number) => boolean): readonly [Chunk<B_1>, Chunk<B_1>];
} & {
    <C_1 extends A_2, B_2 extends A_2, A_2 = C_1>(refinement: (a: A_2, i: number) => a is B_2): (self: Chunk<C_1>) => readonly [Chunk<C_1>, Chunk<B_2>];
    <B_3 extends A_3, A_3 = B_3>(predicate: (a: A_3, i: number) => boolean): (self: Chunk<B_3>) => readonly [Chunk<B_3>, Chunk<B_3>];
};
/**
 * Separate elements based on a predicate.
 *
 * @category filtering
 * @since 1.0.0
 */
export declare const partition: {
    <C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): readonly [Chunk<C>, Chunk<B>];
    <B_1 extends A_1, A_1 = B_1>(self: Chunk<B_1>, predicate: Predicate<A_1>): readonly [Chunk<B_1>, Chunk<B_1>];
} & {
    <C_1 extends A_2, B_2 extends A_2, A_2 = C_1>(refinement: Refinement<A_2, B_2>): (self: Chunk<C_1>) => readonly [Chunk<C_1>, Chunk<B_2>];
    <B_3 extends A_3, A_3 = B_3>(predicate: Predicate<A_3>): (self: Chunk<B_3>) => readonly [Chunk<B_3>, Chunk<B_3>];
};
/**
 * Partitions the elements of this chunk into two chunks using f.
 *
 * @category filtering
 * @since 1.0.0
 */
export declare const partitionMap: (<A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>) => readonly [Chunk<B>, Chunk<C>]) & (<A_1, B_1, C_1>(f: (a: A_1) => Either<B_1, C_1>) => (self: Chunk<A_1>) => readonly [Chunk<B_1>, Chunk<C_1>]);
/**
 * Partitions the elements of this chunk into two chunks.
 *
 * @category filtering
 * @since 1.0.0
 */
export declare const separate: <A, B>(self: Chunk<Either<A, B>>) => readonly [Chunk<A>, Chunk<B>];
/**
 * Create a non empty `Chunk` containing a range of integers, including both endpoints.
 *
 * @category constructors
 * @since 1.0.0
 */
export declare const range: (start: number, end: number) => NonEmptyChunk<number>;
/**
 * Reverse a Chunk, creating a new Chunk.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const reverse: <A>(self: Chunk<A>) => Chunk<A>;
/**
 * Retireves the size of the chunk
 *
 * @since 1.0.0
 * @category elements
 */
export declare const size: <A>(self: Chunk<A>) => number;
/**
 * Sort the elements of a Chunk in increasing order, creating a new Chunk.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const sort: (<A extends B, B>(self: Chunk<A>, O: Order<B>) => Chunk<A>) & (<B_1>(O: Order<B_1>) => <A_1 extends B_1>(self: Chunk<A_1>) => Chunk<A_1>);
/**
 *  Returns two splits of this chunk at the specified index.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const splitAt: (<A>(self: Chunk<A>, n: number) => readonly [Chunk<A>, Chunk<A>]) & ((n: number) => <A_1>(self: Chunk<A_1>) => readonly [Chunk<A_1>, Chunk<A_1>]);
/**
 * Splits this chunk into `n` equally sized chunks.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const split: (<A>(self: Chunk<A>, n: number) => Chunk<Chunk<A>>) & ((n: number) => <A_1>(self: Chunk<A_1>) => Chunk<Chunk<A_1>>);
/**
 * Splits this chunk on the first element that matches this predicate.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const splitWhere: (<A>(self: Chunk<A>, f: Predicate<A>) => readonly [Chunk<A>, Chunk<A>]) & (<A_1>(f: Predicate<A_1>) => (self: Chunk<A_1>) => readonly [Chunk<A_1>, Chunk<A_1>]);
/**
 * Returns every elements after the first.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const tail: <A>(self: Chunk<A>) => Option<Chunk<A>>;
/**
 * Takes the last `n` elements.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const takeRight: (<A>(self: Chunk<A>, n: number) => Chunk<A>) & ((n: number) => <A_1>(self: Chunk<A_1>) => Chunk<A_1>);
/**
 * Takes all elements so long as the predicate returns true.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const takeWhile: (<A>(self: Chunk<A>, f: Predicate<A>) => Chunk<A>) & (<A_1>(f: Predicate<A_1>) => (self: Chunk<A_1>) => Chunk<A_1>);
/**
 * Constructs a `Chunk` by repeatedly applying the function `f` as long as it * returns `Some`.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const unfold: <A, S>(s: S, f: (s: S) => Option<readonly [A, S]>) => Chunk<A>;
/**
 * Creates a Chunks of unique values, in order, from all given Chunks.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const union: (<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A | B>) & (<A_1>(that: Chunk<A_1>) => <B_1>(self: Chunk<B_1>) => Chunk<A_1 | B_1>);
/**
 * Remove duplicates from an array, keeping the first occurrence of an element.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const dedupe: <A>(self: Chunk<A>) => Chunk<A>;
/**
 * Returns the first element of this chunk.
 *
 * @since 1.0.0
 * @category unsafe
 */
export declare const unsafeHead: <A>(self: Chunk<A>) => A;
/**
 * Returns the last element of this chunk.
 *
 * @since 1.0.0
 * @category unsafe
 */
export declare const unsafeLast: <A>(self: Chunk<A>) => A;
/**
 * Takes an array of pairs and return two corresponding arrays.
 *
 * Note: The function is reverse of `zip`.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const unzip: <A, B>(as: Chunk<readonly [A, B]>) => readonly [Chunk<A>, Chunk<B>];
/**
 * Zips this chunk pointwise with the specified chunk.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const zip: (<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [A, B]>) & (<B_1>(that: Chunk<B_1>) => <A_1>(self: Chunk<A_1>) => Chunk<readonly [A_1, B_1]>);
/**
 * Zips this chunk pointwise with the specified chunk using the specified combiner.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const zipWith: (<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C) => Chunk<C>) & (<A_1, B_1, C_1>(that: Chunk<B_1>, f: (a: A_1, b: B_1) => C_1) => (self: Chunk<A_1>) => Chunk<C_1>);
/**
 * Zips this chunk pointwise with the specified chunk to produce a new chunk with
 * pairs of elements from each chunk, filling in missing values from the
 * shorter chunk with `None`. The returned chunk will have the length of the
 * longer chunk.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const zipAll: (<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [Option<A>, Option<B>]>) & (<B_1>(that: Chunk<B_1>) => <A_1>(self: Chunk<A_1>) => Chunk<readonly [Option<A_1>, Option<B_1>]>);
/**
 * Zips with chunk with the specified chunk to produce a new chunk with
 * pairs of elements from each chunk combined using the specified function
 * `both`. If one chunk is shorter than the other uses the specified
 * function `left` or `right` to map the element that does exist to the
 * result type.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const zipAllWith: (<A, B, C, D, E>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C, left: (a: A) => D, right: (b: B) => E) => Chunk<C | D | E>) & (<A_1, B_1, C_1, D_1, E_1>(that: Chunk<B_1>, f: (a: A_1, b: B_1) => C_1, left: (a: A_1) => D_1, right: (b: B_1) => E_1) => (self: Chunk<A_1>) => Chunk<C_1 | D_1 | E_1>);
/**
 * Zips this chunk crosswise with the specified chunk using the specified combiner.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const crossWith: (<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C) => Chunk<C>) & (<A_1, B_1, C_1>(that: Chunk<B_1>, f: (a: A_1, b: B_1) => C_1) => (self: Chunk<A_1>) => Chunk<C_1>);
/**
 * Zips this chunk crosswise with the specified chunk.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const cross: (<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [A, B]>) & (<B_1>(that: Chunk<B_1>) => <A_1>(self: Chunk<A_1>) => Chunk<readonly [A_1, B_1]>);
/**
 * Zips this chunk with the index of every element, starting from the initial
 * index value.
 *
 * @category elements
 * @since 1.0.0
 */
export declare const zipWithIndex: <A>(self: Chunk<A>) => Chunk<readonly [A, number]>;
/**
 * Zips this chunk with the index of every element, starting from the initial
 * index value.
 *
 * @category elements
 * @since 1.0.0
 */
export declare const zipWithIndexOffset: (<A>(self: Chunk<A>, offset: number) => Chunk<[A, number]>) & ((offset: number) => <A_1>(self: Chunk<A_1>) => Chunk<[A_1, number]>);
/**
 * Delete the element at the specified index, creating a new `Chunk`,
 * or returning the input if the index is out of bounds.
 *
 * @category mutations
 * @since 1.0.0
 */
export declare const remove: (<A>(self: Chunk<A>, i: number) => Chunk<A>) & ((i: number) => <A_1>(self: Chunk<A_1>) => Chunk<A_1>);
/**
 * Change the element at the specified index, creating a new `Chunk`,
 * or returning the input if the index is out of bounds.
 *
 * @category mutations
 * @since 1.0.0
 */
export declare const replace: (<A, B>(self: Chunk<A>, i: number, b: B) => Chunk<A | B>) & (<B_1>(i: number, b: B_1) => <A_1>(self: Chunk<A_1>) => Chunk<B_1 | A_1>);
/**
 * @category mutations
 * @since 1.0.0
 */
export declare const replaceOption: (<A, B>(self: Chunk<A>, i: number, b: B) => Option<Chunk<A | B>>) & (<B_1>(i: number, b: B_1) => <A_1>(self: Chunk<A_1>) => Option<Chunk<B_1 | A_1>>);
/**
 * 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.
 *
 * @category mutations
 * @since 1.0.0
 */
export declare const modify: (<A, B>(self: Chunk<A>, i: number, f: (a: A) => B) => Chunk<A | B>) & (<A_1, B_1>(i: number, f: (a: A_1) => B_1) => (self: Chunk<A_1>) => Chunk<A_1 | B_1>);
/**
 * @category mutations
 * @since 1.0.0
 */
export declare const modifyOption: (<A, B>(self: Chunk<A>, i: number, f: (a: A) => B) => Option<Chunk<A | B>>) & (<A_1, B_1>(i: number, f: (a: A_1) => B_1) => (self: Chunk<A_1>) => Option<Chunk<A_1 | B_1>>);
/**
 * Returns the first element of this non empty chunk.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const headNonEmpty: <A>(self: NonEmptyChunk<A>) => A;
/**
 * Returns every elements after the first.
 *
 * @since 1.0.0
 * @category elements
 */
export declare const tailNonEmpty: <A>(self: NonEmptyChunk<A>) => Chunk<A>;
export {};
//# sourceMappingURL=Chunk.d.ts.map