/**
 * Resizable typed array utilities.
 *
 * Wraps typed arrays with automatic buffer expansion (ArrayList semantics).
 * Uses SharedArrayBuffer (if available) for zero-copy worker transfer.
 *
 * @module
 */
/**
 * Use SharedArrayBuffer if the runtime supports it, otherwise fall back to ArrayBuffer.
 * SharedArrayBuffer enables zero-copy transfer between workers.
 */
export declare const BufferConstructor: ArrayBufferConstructor | SharedArrayBufferConstructor;
/** The buffer type used by this runtime (SharedArrayBuffer or ArrayBuffer). */
export type BufferType = InstanceType<typeof BufferConstructor>;
/**
 * Union of all standard typed array types.
 * Generic over buffer type to preserve SharedArrayBuffer compatibility.
 */
export type TypedArray<B extends BufferType = BufferType> = Int8Array<B> | Uint8Array<B> | Uint8ClampedArray<B> | Int16Array<B> | Uint16Array<B> | Int32Array<B> | Uint32Array<B> | Float32Array<B> | Float64Array<B>;
/**
 * Constructor interface for typed arrays.
 */
export interface TypedArrayConstructor<T extends TypedArray<BufferType> = TypedArray<BufferType>> {
    new (buffer: BufferType): T;
    readonly BYTES_PER_ELEMENT: number;
}
/**
 * Float64Array for storing OSM IDs.
 *
 * OSM IDs are 64-bit integers. JavaScript's number type (IEEE 754 double)
 * can exactly represent integers up to 2^53, which covers all current OSM IDs.
 * Float64Array allows typed array operations while maintaining precision.
 */
export declare const IdArrayType: Float64ArrayConstructor;
/**
 * Uint32Array for storing array indices.
 *
 * Internal indices into typed arrays never exceed 2^32 elements,
 * so Uint32Array provides the best balance of range and memory efficiency.
 */
export declare const IndexArrayType: Uint32ArrayConstructor;
/**
 * Initial buffer size for ResizeableTypedArray.
 * 1 MiB provides reasonable initial capacity while avoiding excessive memory allocation.
 */
export declare const DEFAULT_BUFFER_SIZE: number;
/**
 * Auto-expanding typed array wrapper.
 *
 * - `push()` appends elements, doubling buffer size as needed.
 * - `compact()` shrinks buffer to fit data.
 * - Supports growable SharedArrayBuffer and resizable ArrayBuffer.
 */
export declare class ResizeableTypedArray<TA extends TypedArray> {
    /** The typed array constructor for this instance */
    ArrayType: TypedArrayConstructor<TA>;
    /** The current typed array view into the buffer */
    array: TA;
    /** Number of items actually stored (may be less than array.length) */
    items: number;
    /** The underlying ArrayBuffer or SharedArrayBuffer */
    buffer: BufferType;
    /** Current buffer size in bytes */
    bufferSize: number;
    /** Maximum byte length for growable buffers */
    maxByteLength: number;
    /** Buffer constructor (SharedArrayBuffer or ArrayBuffer) */
    BC: SharedArrayBufferConstructor | ArrayBufferConstructor;
    /**
     * Reconstruct a ResizeableTypedArray from an existing buffer.
     *
     * Used after transferring buffers between workers. The resulting array
     * is considered "compacted" with items = array.length.
     *
     * @param ArrayType - The typed array constructor.
     * @param buffer - The existing buffer to wrap.
     * @returns A new ResizeableTypedArray wrapping the buffer.
     */
    static from<TA extends TypedArray>(ArrayType: TypedArrayConstructor<TA>, buffer: BufferType): ResizeableTypedArray<TA>;
    /**
     * Create a new ResizeableTypedArray with an empty buffer.
     *
     * @param ArrayType - The typed array constructor (e.g., Float64Array).
     * @param BC - Buffer constructor to use (defaults to SharedArrayBuffer if available).
     */
    constructor(ArrayType: TypedArrayConstructor<TA>, BC?: SharedArrayBufferConstructor | ArrayBufferConstructor);
    /**
     * Iterate over the array values.
     */
    [Symbol.iterator](): ArrayIterator<number>;
    /**
     * Double the buffer capacity.
     * Uses in-place grow/resize if supported, otherwise allocates new buffer and copies.
     */
    expandArray(): void;
    /**
     * Get the value at an index. Handles negative indices.
     */
    at(index: number): number;
    /**
     * Get a slice of the array.
     */
    slice(start: number, end: number): Float32Array<ArrayBuffer> | Float64Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Uint8Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer>;
    get length(): number;
    /**
     * Push a value to the end of the array.
     */
    push(value: number): number;
    /**
     * Set a value at a specific index. Expands array if needed.
     */
    set(index: number, value: number): void;
    /**
     * Push multiple values to the end of the array.
     */
    pushMany(values: number[] | TypedArray): void;
    /**
     * Shrink the buffer to exactly fit stored items.
     * Buffer becomes fixed-length after compacting.
     */
    compact(): TA;
}
//# sourceMappingURL=typed-arrays.d.ts.map