export declare const kState: unique symbol;
export declare const kType: unique symbol;
export declare function isBrandCheck<T>(brand: string): (value: unknown) => value is T;
/**
 * Internal controller shape these queue helpers operate on. Each controller
 * stores its pending chunks under `[kState].queue` (a list of `{ value, size }`
 * records) together with a running `queueTotalSize`. The element type `T` is
 * the chunk/value type and flows back out of `dequeueValue`/`peekQueueValue`.
 */
interface QueueState<T> {
    queue: {
        value: T;
        size: number;
    }[];
    queueTotalSize: number;
}
type QueueController<T> = {
    [kState]: QueueState<T>;
};
export declare function dequeueValue<T>(controller: QueueController<T>): T;
export declare function resetQueue<E>(controller: {
    [kState]: {
        queue: E[];
        queueTotalSize: number;
    };
}): void;
export declare function peekQueueValue<T>(controller: QueueController<T>): T;
export declare function enqueueValueWithSize<T>(controller: QueueController<T>, value: T, size: number): void;
export declare function extractHighWaterMark(value: number | undefined, defaultHWM: number): number;
export declare function extractSizeAlgorithm<T>(size: ((chunk: T) => number) | undefined): (chunk: T) => number;
export declare function cloneAsUint8Array(view: ArrayBufferView): Uint8Array;
export declare function transferArrayBuffer(buffer: ArrayBufferLike): ArrayBuffer;
export declare function isDetachedBuffer(buffer: ArrayBufferLike): boolean;
/**
 * Constructor shape that this module's TypedArray lookup returns. Each
 * concrete typed-array constructor (`Int8Array`, `Uint8Array`, …) accepts a
 * `(buffer, byteOffset?, length?)` triple, but TS's lib.es5 types declare
 * incompatible signatures across the family (e.g. `BigInt64Array` requires a
 * specific buffer kind). Casting through this local alias preserves call-site
 * type safety (the returned value is callable as a constructor) without
 * littering the switch arms with `as any`.
 */
type ArrayBufferViewCtor = new (buffer: ArrayBufferLike, byteOffset?: number, length?: number) => ArrayBufferView;
export declare function typedArrayConstructorByTag(tag: string | undefined): ArrayBufferViewCtor | undefined;
export declare function elementSizeByTag(tag: string | undefined): number;
export declare function ArrayBufferViewGetBuffer(view: ArrayBufferView): ArrayBuffer;
export declare function ArrayBufferViewGetByteLength(view: ArrayBufferView): number;
export declare function ArrayBufferViewGetByteOffset(view: ArrayBufferView): number;
export declare function setPromiseHandled(promise: Promise<unknown>): void;
export declare function createPromiseCallback(name: string, fn: Function, thisArg: unknown): (...args: unknown[]) => Promise<any>;
export declare function nonOpFlush(): Promise<void>;
export declare function nonOpStart(): void;
export declare function nonOpPull(): Promise<void>;
export declare function nonOpCancel(): Promise<void>;
export declare function nonOpWrite(): Promise<void>;
export declare const AsyncIterator: {
    __proto__: any;
    next: (() => Promise<IteratorResult<unknown>>) | undefined;
    return: ((value?: unknown) => Promise<IteratorResult<unknown>>) | undefined;
};
export declare function createAsyncFromSyncIterator(syncIteratorRecord: {
    iterator: Iterator<unknown>;
    nextMethod: Function;
    done: boolean;
}): {
    iterator: AsyncGenerator<unknown, any, any>;
    nextMethod: (...[value]: [] | [any]) => Promise<IteratorResult<unknown, any>>;
    done: boolean;
};
export declare function getIterator(obj: Record<string | symbol, unknown>, kind?: 'sync' | 'async', method?: Function): any;
export declare function iteratorNext(iteratorRecord: {
    iterator: unknown;
    nextMethod: Function;
    done: boolean;
}, value?: unknown): any;
export {};