/// <reference types="node" />
import { Collection } from "@tsplus/stdlib/collections/Collection/definition";
import { HKT } from "@tsplus/stdlib/prelude/HKT";
import { Equals } from "@tsplus/stdlib/structure/Equals";
import { Hash } from "@tsplus/stdlib/structure/Hash";
import { AtomicNumber } from "@tsplus/stdlib/data/AtomicNumber";
import { IndexOutOfBounds } from "@tsplus/stdlib/exceptions";
export declare const BufferSize = 64;
export declare const ChunkTypeId: unique symbol;
export type ChunkTypeId = typeof ChunkTypeId;
export declare const alloc: ((size: number, fill?: string | number | Buffer | undefined, encoding?: BufferEncoding | undefined) => Buffer) | ((n: number) => Uint8Array);
export declare function isByte(u: unknown): boolean;
export type IterableArrayLike<A> = ArrayLike<A> & Iterable<A>;
/**
 * A `Chunk<A>` represents a chunk of values of type `A`. Chunks are usually
 * backed by arrays, but expose a purely functional, safe interface
 * to the underlying elements, and they become lazy on operations that would be
 * costly with arrays, such as repeated concatenation.
 *
 * The implementation of balanced concatenation is based on the one for
 * Conc-Trees in "Conc-Trees for Functional and Parallel Programming" by
 * Aleksandar Prokopec and Martin Odersky.
 *
 * http://aleksandar-prokopec.com/resources/docs/lcpc-conc-trees.pdf
 *
 * @tsplus type Chunk
 */
export interface Chunk<A> extends Collection<A> {
    readonly [ChunkTypeId]: ChunkTypeId;
    readonly length: number;
    [Symbol.iterator](): Iterator<A>;
}
export interface ChunkF extends HKT {
    readonly type: Chunk<this["A"]>;
}
export declare namespace Chunk {
    type HKT = ChunkF;
}
/**
 * @tsplus type Chunk.Ops
 */
export interface ChunkOps {
    $: ChunkAspects;
}
export declare const Chunk: ChunkOps;
/**
 * @tsplus type Chunk.Aspects
 */
export interface ChunkAspects {
}
/**
 * @tsplus unify Chunk
 */
export declare function unifyChunk<X extends Chunk<any>>(self: X): Chunk<[X] extends [Chunk<infer A>] ? A : never>;
/**
 * Internal base class
 */
export declare abstract class ChunkInternal<A> implements Chunk<A>, Equals {
    readonly [ChunkTypeId]: ChunkTypeId;
    abstract readonly binary: boolean;
    abstract readonly length: number;
    abstract readonly depth: number;
    abstract readonly left: ChunkInternal<A>;
    abstract readonly right: ChunkInternal<A>;
    abstract _copyToArray(n: number, array: Array<A> | Uint8Array): void;
    abstract _get(n: number): A;
    protected arrayLikeCache: IterableArrayLike<unknown> | undefined;
    _arrayLike(): IterableArrayLike<A>;
    private arrayCache;
    _array(): readonly A[];
    [Equals.sym](that: unknown): boolean;
    [Hash.sym](): number;
    toString(): string;
    toJSON(): readonly A[];
    abstract [Symbol.iterator](): Iterator<A>;
    abstract _arrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    abstract _reverseArrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    _buckets(): Iterable<IterableArrayLike<A>>;
    _reverseBuckets(): Iterable<IterableArrayLike<A>>;
    _reverse(): Iterable<A>;
    _materialize(): ChunkInternal<A>;
    _append<A1>(a1: A1): ChunkInternal<A | A1>;
    _prepend<A1>(a1: A1): ChunkInternal<A | A1>;
    _take(n: number): ChunkInternal<A>;
    _concat<A1>(that: ChunkInternal<A1>): ChunkInternal<A | A1>;
}
export declare const EmptyTypeId: unique symbol;
export type EmptyTypeId = typeof EmptyTypeId;
/**
 * Internal Empty Chunk
 */
export declare class Empty<A> extends ChunkInternal<A> {
    readonly depth = 0;
    readonly _typeId: EmptyTypeId;
    readonly left: this;
    readonly right: this;
    readonly binary = true;
    readonly length = 0;
    _get(n: number): A;
    constructor();
    _materialize(): ChunkInternal<never>;
    _copyToArray(_n: number, _array: Array<A> | Uint8Array): void;
    [Symbol.iterator](): Iterator<A>;
    _arrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    _reverseArrayLikeIterator(): Iterator<IterableArrayLike<A>>;
}
export declare const _Empty: ChunkInternal<never>;
/**
 * @tsplus macro remove
 */
export declare function concreteChunk<A>(_: Chunk<A>): asserts _ is Empty<A> | AppendN<A> | Arr<A> | Slice<A> | Singleton<A> | PrependN<A> | Concat<A>;
/**
 * @tsplus macro identity
 */
export declare function concreteChunkId<A>(_: Chunk<A>): Empty<A> | AppendN<A> | Arr<A> | Slice<A> | Singleton<A> | PrependN<A> | Concat<A>;
export declare const AppendNTypeId: unique symbol;
export type AppendNTypeId = typeof AppendNTypeId;
/**
 * Internal Append Chunk
 */
export declare class AppendN<A> extends ChunkInternal<A> {
    readonly start: ChunkInternal<A>;
    readonly buffer: Array<unknown> | Uint8Array;
    readonly bufferUsed: number;
    readonly chain: AtomicNumber;
    readonly binary: boolean;
    readonly _typeId: AppendNTypeId;
    readonly depth = 0;
    readonly left: ChunkInternal<never>;
    readonly right: ChunkInternal<never>;
    readonly length: number;
    constructor(start: ChunkInternal<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, chain: AtomicNumber, binary: boolean);
    _get(n: number): A;
    _append<A1>(a1: A1): ChunkInternal<A | A1>;
    _copyToArray(n: number, array: Array<A> | Uint8Array): void;
    [Symbol.iterator](): Iterator<A>;
    _arrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    _reverseArrayLikeIterator(): Iterator<IterableArrayLike<A>>;
}
export declare const ArrTypeId: unique symbol;
export type ArrTypeId = typeof ArrTypeId;
/**
 * Internal Array Chunk
 */
export declare abstract class Arr<A> extends ChunkInternal<A> {
    readonly _typeId: ArrTypeId;
}
/**
 * Internal Plain Array Chunk
 */
export declare class PlainArr<A> extends Arr<A> {
    readonly array: readonly A[];
    readonly depth = 0;
    readonly left: ChunkInternal<never>;
    readonly right: ChunkInternal<never>;
    readonly length: number;
    private isBytes?;
    constructor(array: readonly A[]);
    get binary(): boolean;
    _get(n: number): A;
    _arrayLike(): IterableArrayLike<A>;
    _array(): readonly A[];
    _materialize(): this;
    _copyToArray(n: number, array: Array<A> | Uint8Array): void;
    [Symbol.iterator](): Iterator<A>;
    _arrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    _reverseArrayLikeIterator(): Iterator<IterableArrayLike<A>>;
}
/**
 * Internal Binary Array Chunk
 */
export declare class Uint8Arr extends Arr<number> {
    readonly array: Uint8Array;
    readonly depth = 0;
    readonly left: ChunkInternal<never>;
    readonly right: ChunkInternal<never>;
    readonly length: number;
    readonly binary = true;
    constructor(array: Uint8Array);
    _arrayLike(): Uint8Array;
    _get(n: number): number;
    _materialize(): this;
    _copyToArray(n: number, array: Array<number> | Uint8Array): void;
    [Symbol.iterator](): Iterator<number>;
    _arrayLikeIterator(): Iterator<IterableArrayLike<number>>;
    _reverseArrayLikeIterator(): Iterator<IterableArrayLike<number>>;
}
export declare const SliceTypeId: unique symbol;
export type SliceTypeId = typeof SliceTypeId;
/**
 * Internal Slice Chunk
 */
export declare class Slice<A> extends ChunkInternal<A> {
    readonly chunk: ChunkInternal<A>;
    readonly offset: number;
    readonly length: number;
    readonly depth = 0;
    readonly left: ChunkInternal<never>;
    readonly right: ChunkInternal<never>;
    readonly binary: boolean;
    readonly _typeId: SliceTypeId;
    _get(n: number): A;
    constructor(chunk: ChunkInternal<A>, offset: number, length: number);
    _copyToArray(n: number, array: Array<A> | Uint8Array): void;
    [Symbol.iterator](): Iterator<A>;
    _arrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    _reverseArrayLikeIterator(): Iterator<IterableArrayLike<A>>;
}
export declare const SingletonTypeId: unique symbol;
export type SingletonTypeId = typeof SingletonTypeId;
/**
 * Internal Singleton Chunk
 */
export declare class Singleton<A> extends ChunkInternal<A> {
    readonly a: A;
    readonly depth = 0;
    readonly left: ChunkInternal<never>;
    readonly right: ChunkInternal<never>;
    readonly length = 1;
    readonly _typeId: SingletonTypeId;
    _get(n: number): A;
    readonly binary: boolean;
    constructor(a: A);
    _copyToArray(n: number, array: Array<A> | Uint8Array): void;
    [Symbol.iterator](): Iterator<A>;
    _arrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    _reverseArrayLikeIterator(): Iterator<IterableArrayLike<A>>;
}
export declare const PrependNTypeId: unique symbol;
export type PrependNTypeId = typeof PrependNTypeId;
/**
 * Internal Prepend Chunk
 */
export declare class PrependN<A> extends ChunkInternal<A> {
    readonly end: ChunkInternal<A>;
    readonly buffer: Array<unknown> | Uint8Array;
    readonly bufferUsed: number;
    readonly chain: AtomicNumber;
    readonly binary: boolean;
    readonly depth = 0;
    readonly left: ChunkInternal<never>;
    readonly right: ChunkInternal<never>;
    readonly length: number;
    readonly _typeId: PrependNTypeId;
    _get(n: number): A;
    constructor(end: ChunkInternal<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, chain: AtomicNumber, binary: boolean);
    _copyToArray(n: number, array: Array<A> | Uint8Array): void;
    prepend<A1>(a1: A1): ChunkInternal<A | A1>;
    [Symbol.iterator](): Iterator<A>;
    _arrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    _reverseArrayLikeIterator(): Iterator<IterableArrayLike<A>>;
}
/**
 * Internal copy arrays
 */
export declare function _copy<A>(src: IterableArrayLike<A>, srcPos: number, dest: A[] | Uint8Array, destPos: number, len: number): Uint8Array | A[];
export declare const ConcatTypeId: unique symbol;
export type ConcatTypeId = typeof ConcatTypeId;
/**
 * Internal Concat Chunk
 */
export declare class Concat<A> extends ChunkInternal<A> {
    readonly left: ChunkInternal<A>;
    readonly right: ChunkInternal<A>;
    readonly depth: number;
    readonly _typeId: ConcatTypeId;
    readonly length: number;
    readonly binary: boolean;
    _get(n: number): A;
    constructor(left: ChunkInternal<A>, right: ChunkInternal<A>);
    _copyToArray(n: number, array: Array<A> | Uint8Array): void;
    [Symbol.iterator](): Iterator<A>;
    _arrayLikeIterator(): Iterator<IterableArrayLike<A>>;
    _reverseArrayLikeIterator(): Iterator<IterableArrayLike<A>>;
}
/**
 * Type guard
 * @tsplus static Chunk.Ops isChunk
 * @tsplus location "@tsplus/stdlib/collections/Chunk/definition"
 */
export declare function isChunk<A>(u: Iterable<A>): u is Chunk<A>;
export declare function isChunk(u: unknown): u is Chunk<unknown>;
/**
 * Builds a chunk from an array.
 * @tsplus static Chunk.Ops from
 * @tsplus location "@tsplus/stdlib/collections/Chunk/definition"
 */
export declare function from<A>(array: Iterable<A>): Chunk<A>;
/**
 * Determines whether this chunk and the specified chunk have the same length
 * and every pair of corresponding elements of this chunk and the specified
 * chunk satisfy the specified predicate.
 * @tsplus fluent Chunk corresponds
 * @tsplus location "@tsplus/stdlib/collections/Chunk/definition"
 */
export declare function corresponds_<A, B>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => boolean): boolean;
/**
 * Determines whether this chunk and the specified chunk have the same length
 * and every pair of corresponding elements of this chunk and the specified
 * chunk satisfy the specified predicate.
 * @tsplus static Chunk.Aspects corresponds
 * @tsplus pipeable Chunk corresponds
 * @tsplus location "@tsplus/stdlib/collections/Chunk/definition"
 */
export declare const corresponds: <A, B>(that: Chunk<B>, f: (a: A, b: B) => boolean) => (self: Chunk<A>) => boolean;
//# sourceMappingURL=definition.d.ts.map