@mark1russell7/collections 0.0.0-stage → 0.1.0

package/build/index.d.ts

@@ -0,0 +1,4952 @@
+/**
+ * Core traits and capability interfaces for the collections framework.
+ *
+ * These traits define fundamental capabilities that collections can have,
+ * following the Interface Segregation Principle (SOLID).
+ */
+/**
+ * Equality comparison function.
+ * This type gives true if two values are considered equal.
+ *
+ * @example
+ * const primitiveEq: Eq<number> = (a, b) => a === b
+ * const objectEq: Eq<Person> = (a, b) => a.id === b.id
+ */
+export type Eq<T> = (a: T, b: T) => boolean;
+/**
+ * Hash function for making hash codes.
+ * This type gives a 32-bit integer hash of the value.
+ *
+ * The function must satisfy: if eq(a, b) === true, then hash(a) === hash(b)
+ *
+ * @example
+ * const stringHash: Hash<string> = (s) => {
+ *   let h = 0;
+ *   for (let i = 0; i < s.length; i++) {
+ *     h = ((h << 5) - h) + s.charCodeAt(i);
+ *     h = h & h; // Convert to 32-bit integer
+ *   }
+ *   return h;
+ * }
+ */
+export type Hash<T> = (value: T) => number;
+/**
+ * Comparison function for ordering values.
+ * This type gives:
+ * - negative number if a < b
+ * - zero if a === b
+ * - positive number if a > b
+ *
+ * The function must be transitive and consistent with equality.
+ *
+ * @example
+ * const numberCompare: Compare<number> = (a, b) => a - b
+ * const reverseCompare = <T>(cmp: Compare<T>): Compare<T> => (a, b) => cmp(b, a)
+ */
+export type Compare<T> = (a: T, b: T) => number;
+/**
+ * Capability: Has a size property.
+ */
+export interface Sized {
+  /** The number of elements in the collection. */
+  readonly size: number;
+}
+/**
+ * Capability: Can be cleared (all elements removed).
+ */
+export interface Clearable {
+  /** This method removes all elements from the collection. */
+  clear(): void;
+}
+/**
+ * Capability: Can check if empty.
+ */
+export interface Emptiable {
+  /** This value gives true if the collection contains no elements. */
+  readonly isEmpty: boolean;
+}
+/**
+ * Capability: Can be cloned.
+ */
+export interface Cloneable<T> {
+  /** This method makes a shallow copy of the collection. */
+  clone(): T;
+}
+/**
+ * Capability: Can be converted to an array.
+ */
+export interface ArrayConvertible<T> {
+  /** This method gives an array containing all elements in the collection. */
+  toArray(): T[];
+}
+/**
+ * Base read-only collection capabilities.
+ * This type combines common traits that most collections share.
+ */
+export interface ReadonlyCollectionBase<T> extends Sized, Emptiable, Iterable<T>, ArrayConvertible<T> {}
+/**
+ * Base mutable collection capabilities.
+ * This type adds mutation operations to readonly base.
+ */
+export interface MutableCollectionBase<T> extends ReadonlyCollectionBase<T>, Clearable {}
+/**
+ * Equality provider - with it, collections can specify custom equality.
+ */
+export interface EqualityProvider<T> {
+  /** The equality function used by this collection. */
+  readonly eq: Eq<T>;
+}
+/**
+ * Hash provider - with it, collections can specify custom hashing.
+ */
+export interface HashProvider<T> {
+  /** The hash function used by this collection. */
+  readonly hash: Hash<T>;
+}
+/**
+ * Comparison provider - with it, collections can specify custom ordering.
+ */
+export interface ComparisonProvider<T> {
+  /** The comparison function used by this collection. */
+  readonly compare: Compare<T>;
+}
+/**
+ * Bounded collection - has a maximum capacity.
+ */
+export interface Bounded {
+  /** The maximum number of elements this collection can hold. */
+  readonly capacity: number;
+  /** This value gives true if the collection is at capacity. */
+  readonly isFull: boolean;
+  /** This value gives the number of elements that the collection can still take. */
+  readonly remainingCapacity: number;
+}
+/**
+ * Disposable resource - can be explicitly cleaned up.
+ */
+export interface Disposable {
+  /** This method releases any resources held by this collection. */
+  dispose(): void;
+}
+/**
+ * Freezable collection - can be made immutable.
+ */
+export interface Freezable<T> {
+  /** This method makes this collection immutable. This method gives self for chaining. */
+  freeze(): T;
+  /** This value gives true if this collection is frozen. */
+  readonly isFrozen: boolean;
+}
+/**
+ * Functional effect types for error handling and optional values.
+ *
+ * This module gives Option<T> and Result<T,E> types for explicit, type-safe
+ * error handling without exceptions. This module includes async variants.
+ */
+/**
+ * This type represents the absence of a value.
+ */
+export interface None {
+  readonly _tag: "None";
+}
+/**
+ * This type represents the presence of a value.
+ */
+export interface Some<T> {
+  readonly _tag: "Some";
+  readonly value: T;
+}
+/**
+ * Option<T> represents a value that is present or absent.
+ * This is a type-safe alternative to null/undefined.
+ *
+ * @example
+ * function findUser(id: string): Option<User> {
+ *   const user = db.get(id);
+ *   return user ? Some(user) : None;
+ * }
+ */
+export type Option<T> = None | Some<T>;
+/**
+ * The singleton None value.
+ */
+export declare const None: None;
+/**
+ * This function constructs a Some value containing the given value.
+ */
+export declare const Some: <T>(value: T) => Some<T>;
+/**
+ * Type guard to check if an Option is None.
+ */
+export declare const isNone: <T>(opt: Option<T>) => opt is None;
+/**
+ * Type guard to check if an Option is Some.
+ */
+export declare const isSome: <T>(opt: Option<T>) => opt is Some<T>;
+/**
+ * This function extracts the value from a Some, or gives the default value if None.
+ */
+export declare const getOrElse: <T>(opt: Option<T>, defaultValue: T) => T;
+/**
+ * This function extracts the value from a Some, or throws an error if None.
+ */
+export declare const unwrap: <T>(opt: Option<T>) => T;
+/**
+ * This function maps a function over the value in a Some, or gives None.
+ */
+export declare const mapOption: <T, U>(opt: Option<T>, f: (value: T) => U) => Option<U>;
+/**
+ * Chains Option-returning operations.
+ */
+export declare const flatMapOption: <T, U>(opt: Option<T>, f: (value: T) => Option<U>) => Option<U>;
+/**
+ * This function converts a nullable value to an Option.
+ */
+export declare const fromNullable: <T>(value: T | null | undefined) => Option<T>;
+/**
+ * This function converts an Option to a nullable value.
+ */
+export declare const toNullable: <T>(opt: Option<T>) => T | undefined;
+/**
+ * This type represents a successful result containing a value.
+ */
+export interface Ok<T> {
+  readonly _tag: "Ok";
+  readonly value: T;
+  /** This method calls the `Ok` case with the value. */
+  match<U>(cases: {
+    Ok: (value: T) => U;
+    Err: (error: never) => U;
+  }): U;
+}
+/**
+ * This type represents a failed result containing an error.
+ */
+export interface Err<E> {
+  readonly _tag: "Err";
+  readonly error: E;
+  /** This method calls the `Err` case with the error. */
+  match<U>(cases: {
+    Ok: (value: never) => U;
+    Err: (error: E) => U;
+  }): U;
+}
+/**
+ * Result<T, E> represents the result of an operation that can fail.
+ * It contains either a success value (Ok) or an error value (Err).
+ *
+ * @example
+ * function divide(a: number, b: number): Result<number, string> {
+ *   if (b === 0) return Err("Division by zero");
+ *   return Ok(a / b);
+ * }
+ */
+export type Result<T, E> = Ok<T> | Err<E>;
+/**
+ * This function constructs an Ok result containing the given value.
+ */
+export declare const Ok: <T>(value: T) => Ok<T>;
+/**
+ * This function constructs an Err result containing the given error.
+ */
+export declare const Err: <E>(error: E) => Err<E>;
+/**
+ * Type guard to check if a Result is Ok.
+ */
+export declare const isOk: <T, E>(result: Result<T, E>) => result is Ok<T>;
+/**
+ * Type guard to check if a Result is Err.
+ */
+export declare const isErr: <T, E>(result: Result<T, E>) => result is Err<E>;
+/**
+ * This function extracts the value from an Ok, or gives the default value if Err.
+ */
+export declare const getOrElseResult: <T, E>(result: Result<T, E>, defaultValue: T) => T;
+/**
+ * This function extracts the value from an Ok, or throws the error if Err.
+ */
+export declare const unwrapResult: <T, E>(result: Result<T, E>) => T;
+/**
+ * This function maps a function over the value in an Ok, or gives the Err unchanged.
+ */
+export declare const mapResult: <T, U, E>(result: Result<T, E>, f: (value: T) => U) => Result<U, E>;
+/**
+ * This function maps a function over the error in an Err, or gives the Ok unchanged.
+ */
+export declare const mapError: <T, E, F>(result: Result<T, E>, f: (error: E) => F) => Result<T, F>;
+/**
+ * Chains Result-returning operations.
+ */
+export declare const flatMapResult: <T, U, E>(result: Result<T, E>, f: (value: T) => Result<U, E>) => Result<U, E>;
+/**
+ * This function converts a throwing function into a Result-returning function.
+ */
+export declare const tryCatch: <T, E = unknown>(fn: () => T, onError?: (error: unknown) => E) => Result<T, E>;
+/**
+ * This function converts an async throwing function into a Result-returning async function.
+ */
+export declare const tryCatchAsync: <T, E = unknown>(fn: () => Promise<T>, onError?: (error: unknown) => E) => Promise<Result<T, E>>;
+/**
+ * Async variant of Option<T>.
+ */
+export type AsyncOption<T> = Promise<Option<T>>;
+/**
+ * Async variant of Result<T, E>.
+ */
+export type AsyncResult<T, E> = Promise<Result<T, E>>;
+/**
+ * This function maps a function over an async Option.
+ */
+export declare const mapAsyncOption: <T, U>(opt: AsyncOption<T>, f: (value: T) => U | Promise<U>) => AsyncOption<U>;
+/**
+ * This function maps a function over an async Result.
+ */
+export declare const mapAsyncResult: <T, U, E>(result: AsyncResult<T, E>, f: (value: T) => U | Promise<U>) => AsyncResult<U, E>;
+/**
+ * This function converts an Option to a Result.
+ * None becomes Err with the given error.
+ */
+export declare const optionToResult: <T, E>(opt: Option<T>, error: E) => Result<T, E>;
+/**
+ * This function converts a Result to an Option.
+ * Err becomes None, discarding the error.
+ */
+export declare const resultToOption: <T, E>(result: Result<T, E>) => Option<T>;
+/**
+ * This function combines multiple Options into an Option of an array.
+ * This function gives None if any input is None.
+ */
+export declare const sequence: <T>(opts: Option<T>[]) => Option<T[]>;
+/**
+ * This function combines multiple Results into a Result of an array.
+ * This function gives the first Err encountered, or Ok with all values.
+ */
+export declare const sequenceResults: <T, E>(results: Result<T, E>[]) => Result<T[], E>;
+/**
+ * Policy types for configurable collection behaviors.
+ *
+ * Policies define how collections handle edge cases like overflow,
+ * underflow, and eviction. These are used by behavior decorators
+ * to give flexible, composable behavior.
+ */
+/**
+ * Policy for handling overflow when adding to a full bounded collection.
+ *
+ * - 'throw': Throw an error when trying to add to a full collection
+ * - 'drop-oldest': Remove the oldest element and add the new one
+ * - 'drop-newest': Ignore the new element (don't add it)
+ * - 'reject': Return false/None but don't throw (graceful failure)
+ * - 'grow': Automatically increase capacity (becomes unbounded)
+ * - 'block': For async collections, wait until space is available
+ */
+export type OverflowPolicy = "throw" | "drop-oldest" | "drop-newest" | "reject" | "grow" | "block";
+/**
+ * Context information given when overflow occurs.
+ */
+export interface OverflowContext<T> {
+  /** The element that triggered the overflow. */
+  readonly newElement: T;
+  /** Current size of the collection. */
+  readonly currentSize: number;
+  /** Maximum capacity of the collection. */
+  readonly capacity: number;
+  /** Timestamp when overflow occurred. */
+  readonly timestamp: number;
+}
+/**
+ * Callback invoked when overflow occurs.
+ * This function can log, record metrics or do custom handling.
+ */
+export type OverflowHandler<T> = (context: OverflowContext<T>) => void;
+/**
+ * Policy for handling underflow when removing from an empty collection.
+ *
+ * - 'throw': Throw an error when trying to remove from empty collection
+ * - 'return-none': Return None/undefined (graceful failure)
+ * - 'return-default': Give a default value given by user
+ * - 'block': For async collections, wait until an element is available
+ */
+export type UnderflowPolicy = "throw" | "return-none" | "return-default" | "block";
+/**
+ * Context information given when underflow occurs.
+ */
+export interface UnderflowContext {
+  /** The operation that triggered the underflow. */
+  readonly operation: string;
+  /** Timestamp when underflow occurred. */
+  readonly timestamp: number;
+}
+/**
+ * Callback invoked when underflow occurs.
+ */
+export type UnderflowHandler = (context: UnderflowContext) => void;
+/**
+ * Policy for choosing which element to evict from a bounded collection.
+ *
+ * - 'lru': Least Recently Used - evict element not accessed for longest time
+ * - 'lfu': Least Frequently Used - evict element accessed least often
+ * - 'fifo': First In First Out - evict oldest inserted element
+ * - 'lifo': Last In First Out - evict newest inserted element (stack-like)
+ * - 'random': Evict a random element
+ * - 'ttl': Time To Live - evict elements that have expired
+ * - 'priority': Evict element with lowest priority
+ * - 'custom': User-provided eviction function
+ */
+export type EvictionPolicy = "lru" | "lfu" | "fifo" | "lifo" | "random" | "ttl" | "priority" | "custom";
+/**
+ * Metadata tracked for eviction decisions.
+ */
+export interface EvictionMetadata {
+  /** When the element was inserted. */
+  readonly insertedAt: number;
+  /** When the element was last accessed. */
+  lastAccessedAt: number;
+  /** How many times the element has been accessed. */
+  accessCount: number;
+  /** Time-to-live expiration timestamp (if applicable). */
+  readonly expiresAt?: number;
+  /** Priority value (higher = more important, if applicable). */
+  readonly priority?: number;
+}
+/**
+ * Information about an element that can be evicted.
+ */
+export interface EvictionCandidate<T> {
+  /** The element value. */
+  readonly element: T;
+  /** Eviction metadata for this element. */
+  readonly metadata: EvictionMetadata;
+}
+/**
+ * Custom eviction function.
+ * Given candidates, gives the element to evict.
+ */
+export type EvictionSelector<T> = (candidates: EvictionCandidate<T>[]) => T | undefined;
+/**
+ * Policy for retrying failed async operations.
+ */
+export interface RetryPolicy {
+  /** Maximum number of retry tries. */
+  readonly maxAttempts: number;
+  /** Initial delay in milliseconds. */
+  readonly initialDelay: number;
+  /** Backoff strategy. */
+  readonly backoff: "none" | "linear" | "exponential";
+  /** Maximum delay cap (for backoff). */
+  readonly maxDelay?: number;
+  /** Jitter to add randomness and avoid thundering herd. */
+  readonly jitter?: boolean;
+}
+/**
+ * Context for retry decisions.
+ */
+export interface RetryContext {
+  /** Current try number (1-indexed). */
+  readonly attempt: number;
+  /** The error that caused the retry. */
+  readonly error: unknown;
+  /** Elapsed time since first try. */
+  readonly elapsedMs: number;
+}
+/**
+ * Callback to determine if an error is retryable.
+ */
+export type RetryPredicate = (context: RetryContext) => boolean;
+/**
+ * Policy for resolving conflicts when same key is changed concurrently.
+ *
+ * - 'last-write-wins': Most recent write takes precedence
+ * - 'first-write-wins': First write takes precedence
+ * - 'merge': Call merge function to combine values
+ * - 'throw': Throw an error on conflict
+ */
+export type ConflictResolutionPolicy = "last-write-wins" | "first-write-wins" | "merge" | "throw";
+/**
+ * Function to merge conflicting values.
+ */
+export type MergeFunction<T> = (current: T, incoming: T) => T;
+/**
+ * Policy for when to compact internal storage.
+ */
+export interface CompactionPolicy {
+  /** Compact when the used part of the capacity drops below this ratio (0-1). */
+  readonly minLoadFactor?: number;
+  /** Compact when wasted space exceeds this many elements. */
+  readonly maxWastedSpace?: number;
+  /** Automatically compact on every removal. */
+  readonly autoCompact?: boolean;
+}
+/**
+ * Policy for how to grow capacity when needed.
+ */
+export interface GrowthPolicy {
+  /** Growth strategy. */
+  readonly strategy: "double" | "linear" | "golden-ratio" | "custom";
+  /** For linear growth, how many elements to add. */
+  readonly linearIncrement?: number;
+  /** For custom growth, a function to calculate new capacity. */
+  readonly customGrowth?: (currentCapacity: number) => number;
+  /** Maximum capacity limit (prevent unbounded growth). */
+  readonly maxCapacity?: number;
+}
+/**
+ * Validation action when an invalid element is encountered.
+ *
+ * - 'throw': Throw an error
+ * - 'drop': Silently drop the invalid element
+ * - 'coerce': Try to coerce to valid type
+ * - 'log': Log a warning and continue
+ */
+export type ValidationPolicy = "throw" | "drop" | "coerce" | "log";
+/**
+ * Context for validation failures.
+ */
+export interface ValidationContext<T> {
+  /** The invalid element. */
+  readonly element: T;
+  /** Validation error message/details. */
+  readonly error: unknown;
+  /** The operation that triggered validation. */
+  readonly operation: string;
+}
+/**
+ * Callback invoked on validation failures.
+ */
+export type ValidationHandler<T> = (context: ValidationContext<T>) => void;
+/**
+ * Default overflow policy: throw an error.
+ */
+export declare const DEFAULT_OVERFLOW_POLICY: OverflowPolicy;
+/**
+ * Default underflow policy: throw an error.
+ */
+export declare const DEFAULT_UNDERFLOW_POLICY: UnderflowPolicy;
+/**
+ * Default eviction policy: FIFO (oldest first).
+ */
+export declare const DEFAULT_EVICTION_POLICY: EvictionPolicy;
+/**
+ * Default retry policy: 3 tries with exponential backoff.
+ */
+export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+/**
+ * Default conflict resolution: last write wins.
+ */
+export declare const DEFAULT_CONFLICT_POLICY: ConflictResolutionPolicy;
+/**
+ * Default growth policy: double capacity.
+ */
+export declare const DEFAULT_GROWTH_POLICY: GrowthPolicy;
+/**
+ * Default validation policy: throw on invalid.
+ */
+export declare const DEFAULT_VALIDATION_POLICY: ValidationPolicy;
+/**
+ * ReadonlyCollection<T> - The root interface for readonly collections.
+ *
+ * Mirrors java.util.Collection but without mutation operations.
+ * All collections must extend this or a more specific readonly interface.
+ */
+export interface ReadonlyCollection<T> extends Iterable<T> {
+  /**
+   * This value is the number of elements in this collection.
+   */
+  readonly size: number;
+  /**
+   * This value is true if this collection contains no elements.
+   */
+  readonly isEmpty: boolean;
+  /**
+   * This method gives true if this collection contains the specified element.
+   * This method uses the collection's equality function to compare elements.
+   *
+   * @param element The element to check for
+   */
+  contains(element: T): boolean;
+  /**
+   * This method gives true if this collection contains all elements in the specified collection.
+   *
+   * @param other The collection whose elements to check for
+   */
+  containsAll(other: Iterable<T>): boolean;
+  /**
+   * This method gives an array containing all elements in this collection.
+   * The given array is safe to change (it's a copy).
+   */
+  toArray(): T[];
+  /**
+   * This method does the given action for each element.
+   *
+   * @param action The action to do for each element
+   */
+  forEach(action: (element: T, index: number) => void): void;
+  /**
+   * This value is the equality function used by this collection.
+   */
+  readonly eq: Eq<T>;
+}
+/**
+ * Collection<T> - The root interface for mutable collections.
+ *
+ * Mirrors java.util.Collection with mutation operations.
+ * All mutable collections must extend this or a more specific interface.
+ */
+export interface Collection<T> extends ReadonlyCollection<T> {
+  /**
+   * This method adds an element to this collection.
+   *
+   * This method gives true if the collection was changed as a result of this call.
+   * Some collections (like Set) can give false if the element already exists.
+   *
+   * @param element The element to add
+   * @returns true if the collection changed
+   * @throws Error if collection is full (bounded) and policy is 'throw'
+   */
+  add(element: T): boolean;
+  /**
+   * This method adds all elements from the specified collection to this collection.
+   *
+   * @param other The collection whose elements to add
+   * @returns true if the collection changed
+   */
+  addAll(other: Iterable<T>): boolean;
+  /**
+   * This method removes a single instance of the specified element from this collection.
+   *
+   * This method gives true if an element was removed as a result of this call.
+   *
+   * @param element The element to remove
+   * @returns true if an element was removed
+   */
+  remove(element: T): boolean;
+  /**
+   * This method removes all elements from this collection that are also in the specified collection.
+   *
+   * @param other The collection whose elements to remove
+   * @returns true if the collection changed
+   */
+  removeAll(other: Iterable<T>): boolean;
+  /**
+   * This method retains only the elements in this collection that are in the specified collection.
+   * In other words, removes all elements not in the specified collection.
+   *
+   * @param other The collection of elements to retain
+   * @returns true if the collection changed
+   */
+  retainAll(other: Iterable<T>): boolean;
+  /**
+   * This method removes all elements from this collection.
+   * The collection will be empty after this call gives.
+   */
+  clear(): void;
+}
+/**
+ * Utility type to check if a collection is readonly.
+ */
+export type IsReadonly<C> = C extends ReadonlyCollection<any> ? C extends Collection<any> ? false : true : false;
+/**
+ * Extract element type from a collection.
+ */
+export type ElementOf<C> = C extends ReadonlyCollection<infer T> ? T : never;
+/**
+ * Make a collection readonly by removing mutation methods.
+ */
+export type Readonly<C extends Collection<any>> = C extends Collection<infer T> ? ReadonlyCollection<T> : never;
+/**
+ * A middleware is a function that takes a collection and gives
+ * an enhanced version of that collection.
+ *
+ * This maps to the unified middleware pattern where:
+ * - The "context" is the collection itself (passed directly, not in a context object)
+ * - Execution is synchronous (no Promises)
+ * - Type transformation is tracked through In -> Out
+ *
+ * Middleware can:
+ * - Intercept method calls
+ * - Add new capabilities
+ * - Transform inputs/outputs
+ * - Delegate to the next layer
+ *
+ * @template In The input collection type
+ * @template Out The output collection type (defaults to In if not specified)
+ */
+export type Middleware<In = any, Out extends In = In> = (next: In) => Out;
+/**
+ * Composes multiple middleware layers into a single enhancer function.
+ *
+ * This function uses reduceRight to make an "onion" pattern where the first middleware
+ * is the outermost layer (runs first when calling into the collection).
+ *
+ * The type system properly tracks capability additions through composition.
+ *
+ * @example
+ * // Layer order (outer to inner):
+ * // 1. safe - converts throws to Option/Result
+ * // 2. evented - emits events on mutations
+ * // 3. bounded - enforces capacity limits
+ * // 4. base - the underlying ArrayList
+ * const enhancer = compose(
+ *   safeList(),
+ *   eventedList(),
+ *   boundedList({ capacity: 100 })
+ * )
+ * const list = enhancer(arrayList<number>())
+ * // Type: List<number> & SafeCollection & EventedCollection & BoundedCollection
+ *
+ * @param layers The middleware layers to compose
+ * @returns A function that applies all layers to a base collection
+ */
+export declare function compose<C, R1 extends C>(m1: Middleware<C, R1>): (base: C) => R1;
+export declare function compose<C, R1 extends C, R2 extends R1>(m1: Middleware<R1, R2>, m2: Middleware<C, R1>): (base: C) => R2;
+export declare function compose<C, R1 extends C, R2 extends R1, R3 extends R2>(m1: Middleware<R2, R3>, m2: Middleware<R1, R2>, m3: Middleware<C, R1>): (base: C) => R3;
+export declare function compose<C, R1 extends C, R2 extends R1, R3 extends R2, R4 extends R3>(m1: Middleware<R3, R4>, m2: Middleware<R2, R3>, m3: Middleware<R1, R2>, m4: Middleware<C, R1>): (base: C) => R4;
+export declare function compose<C, R1 extends C, R2 extends R1, R3 extends R2, R4 extends R3, R5 extends R4>(m1: Middleware<R4, R5>, m2: Middleware<R3, R4>, m3: Middleware<R2, R3>, m4: Middleware<R1, R2>, m5: Middleware<C, R1>): (base: C) => R5;
+export declare function compose<C>(...layers: Middleware<any, any>[]): (base: C) => any;
+/**
+ * Utility to check if a collection has a specific capability.
+ * Useful for middleware that wants to conditionally enhance behavior.
+ *
+ * @example
+ * if (hasCapability(collection, 'on')) {
+ *   // Collection supports events
+ *   collection.on('add', handler)
+ * }
+ */
+export declare const hasCapability: <C extends Collection<any>, K extends keyof any>(collection: C, capability: K) => collection is C & Record<K, unknown>;
+/**
+ * Marker interface for collections that support events.
+ * Middleware can use this to detect event capability.
+ */
+export interface Evented<E extends Record<string, any>> {
+  /**
+   * Subscribe to an event.
+   * @returns Unsubscribe function
+   */
+  on<K extends keyof E>(event: K, handler: (payload: E[K]) => void): () => void;
+}
+/**
+ * Marker interface for collections that support async operations.
+ */
+export interface Async<T> {
+  /**
+   * Async iterator for consuming elements.
+   */
+  [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+/**
+ * Marker interface for collections that are bounded.
+ */
+export interface BoundedCollection {
+  /** Maximum capacity */
+  readonly capacity: number;
+  /** If collection is at capacity */
+  readonly isFull: boolean;
+  /** Remaining space */
+  readonly remainingCapacity: number;
+}
+/**
+ * Marker interface for collections that support safe (Option/Result) operations.
+ */
+export interface SafeCollection {
+  /**
+   * Namespace for safe operations that return Option/Result instead of throwing.
+   */
+  readonly safe: unknown;
+}
+/**
+ * Type helper to extract the element type from a collection.
+ */
+export type ElementType<C> = C extends {
+  [Symbol.iterator](): Iterator<infer T>;
+} ? T : C extends {
+  get(index: number): infer T;
+} ? T : C extends {
+  peek(): infer T;
+} ? T : never;
+/**
+ * Type helper to make all methods of a type return their async equivalents.
+ */
+export type Asyncify<C> = { [K in keyof C]: C[K] extends ((...args: infer Args) => infer R) ? (...args: Args) => Promise<R> : C[K]; };
+/**
+ * Helper to make a proxy that intercepts method calls.
+ * Useful for implementing middleware that needs to wrap method invocations.
+ *
+ * @example
+ * const logged = interceptMethods(collection, (target, method, args) => {
+ *   console.log(`Calling ${String(method)} with`, args)
+ *   const result = Reflect.apply(target[method], target, args)
+ *   console.log(`Result:`, result)
+ *   return result
+ * })
+ */
+export declare const interceptMethods: <C extends object>(target: C, interceptor: (target: C, method: keyof C, args: unknown[]) => unknown) => C;
+/**
+ * Helper to make a readonly view of a collection by blocking mutating methods.
+ *
+ * @param mutatingMethods Set of method names that the middleware blocks
+ * @param errorMessage Custom error message to throw
+ */
+export declare const blockMethods: <C extends object>(target: C, mutatingMethods: Set<string | symbol>, errorMessage?: string) => C;
+/**
+ * Helper to delegate method calls to a target while maintaining correct context.
+ * Useful when wrapping collections.
+ */
+export declare const delegate: <C extends object, T extends C>(target: T, wrapper: Partial<C>) => C;
+/**
+ * Utility type to add optional capabilities to a collection type.
+ */
+export type WithCapability<C, Cap> = C & Cap;
+/**
+ * Builder pattern helper for fluent API construction.
+ *
+ * @example
+ * class ListBuilder<T> {
+ *   private middleware: Middleware<List<T>>[] = []
+ *
+ *   bounded(capacity: number) {
+ *     this.middleware.push(boundedList({ capacity }))
+ *     return this
+ *   }
+ *
+ *   evented() {
+ *     this.middleware.push(eventedList())
+ *     return this
+ *   }
+ *
+ *   build(): List<T> {
+ *     return compose(...this.middleware)(arrayList<T>())
+ *   }
+ * }
+ */
+export declare abstract class CollectionBuilder<C> {
+  protected middleware: Middleware<C>[];
+  /**
+   * Apply a custom middleware.
+   */
+  use(middleware: Middleware<C>): this;
+  /**
+   * Build the final collection by composing all middleware with the base.
+   */
+  abstract build(): C;
+}
+/**
+ * Utility to make a middleware that only enhances specific methods.
+ *
+ * @example
+ * const logAdd = enhanceMethod('add', (original, args) => {
+ *   console.log('Adding:', args[0])
+ *   return original(...args)
+ * })
+ */
+export declare const enhanceMethod: <C extends object, K extends keyof C & string>(methodName: K, enhancer: (original: C[K] extends ((...args: infer Args) => infer R) ? (...args: Args) => R : never, args: C[K] extends ((...args: infer Args) => any) ? Args : never) => C[K] extends ((...args: any[]) => infer R) ? R : never) => Middleware<C>;
+/**
+ * This function combines multiple middleware into a single middleware.
+ * Useful for making reusable middleware bundles.
+ *
+ * Bundle has the same composition semantics as compose - the first middleware
+ * is the outermost layer, and types are tracked through the chain.
+ *
+ * @example
+ * const standardBehaviors = bundle(
+ *   boundedList({ capacity: 1000 }),
+ *   eventedList(),
+ *   safeList()
+ * )
+ *
+ * const list = compose(standardBehaviors)(arrayList<number>())
+ */
+export declare function bundle<C, R1 extends C>(m1: Middleware<C, R1>): Middleware<C, R1>;
+export declare function bundle<C, R1 extends C, R2 extends R1>(m1: Middleware<R1, R2>, m2: Middleware<C, R1>): Middleware<C, R2>;
+export declare function bundle<C, R1 extends C, R2 extends R1, R3 extends R2>(m1: Middleware<R2, R3>, m2: Middleware<R1, R2>, m3: Middleware<C, R1>): Middleware<C, R3>;
+export declare function bundle<C, R1 extends C, R2 extends R1, R3 extends R2, R4 extends R3>(m1: Middleware<R3, R4>, m2: Middleware<R2, R3>, m3: Middleware<R1, R2>, m4: Middleware<C, R1>): Middleware<C, R4>;
+export declare function bundle<C, R1 extends C, R2 extends R1, R3 extends R2, R4 extends R3, R5 extends R4>(m1: Middleware<R4, R5>, m2: Middleware<R3, R4>, m3: Middleware<R2, R3>, m4: Middleware<R1, R2>, m5: Middleware<C, R1>): Middleware<C, R5>;
+export declare function bundle<C>(...middleware: Middleware<any, any>[]): Middleware<C, any>;
+/**
+ * Typed event emitter system for collections.
+ *
+ * This function gives a lightweight, type-safe event system for mutation events
+ * and other observable behavior. Events are strongly typed using
+ * TypeScript's mapped types.
+ */
+/**
+ * A listener function that receives an event payload.
+ */
+export type Listener<P> = (payload: P) => void;
+/**
+ * A function to unsubscribe from an event.
+ */
+export type Unsubscribe = () => void;
+/**
+ * Event map defining event names and their payload types.
+ *
+ * @example
+ * interface MyEvents {
+ *   add: { value: number; index: number }
+ *   remove: { value: number }
+ *   clear: {}
+ * }
+ */
+export type EventMap = Record<string, any>;
+/**
+ * Type-safe event emitter.
+ *
+ * This class supports subscribing to events, emitting events, and managing listeners.
+ * All event names and payloads are type-checked at compile time.
+ *
+ * @example
+ * interface ListEvents<T> {
+ *   add: { value: T; index: number }
+ *   remove: { value: T; index: number }
+ *   clear: {}
+ * }
+ *
+ * const emitter = new Emitter<ListEvents<number>>()
+ *
+ * const unsub = emitter.on('add', ({ value, index }) => {
+ *   console.log(`Added ${value} at ${index}`)
+ * })
+ *
+ * emitter.emit('add', { value: 42, index: 0 })
+ * unsub() // Unsubscribe
+ */
+export declare class Emitter<E extends EventMap> {
+  private listeners;
+  /**
+   * Subscribe to an event.
+   *
+   * @param event The event name
+   * @param listener The callback to invoke when event is emitted
+   * @returns A function to unsubscribe
+   */
+  on<K extends keyof E>(event: K, listener: Listener<E[K]>): Unsubscribe;
+  /**
+   * Subscribe to an event, but automatically unsubscribe after first emission.
+   *
+   * @param event The event name
+   * @param listener The callback to invoke once
+   * @returns A function to unsubscribe (in case you want to cancel before emission)
+   */
+  once<K extends keyof E>(event: K, listener: Listener<E[K]>): Unsubscribe;
+  /**
+   * Emit an event to all registered listeners.
+   *
+   * @param event The event name
+   * @param payload The event payload
+   */
+  emit<K extends keyof E>(event: K, payload: E[K]): void;
+  /**
+   * Remove all listeners for a specific event, or all events if no event specified.
+   *
+   * @param event Optional event name to clear listeners for
+   */
+  off<K extends keyof E>(event?: K): void;
+  /**
+   * Get the number of listeners for a specific event.
+   *
+   * @param event The event name
+   * @returns Number of registered listeners
+   */
+  listenerCount<K extends keyof E>(event: K): number;
+  /**
+   * Get all event names that have at least one listener.
+   */
+  eventNames(): (keyof E)[];
+  /**
+   * Check if there are any listeners for a specific event.
+   */
+  hasListeners<K extends keyof E>(event: K): boolean;
+  /**
+   * Remove all listeners and clean up resources.
+   */
+  dispose(): void;
+}
+/**
+ * Make an event emitter for a specific event map.
+ *
+ * This is a convenience factory function.
+ *
+ * @example
+ * const events = createEmitter<ListEvents<number>>()
+ */
+export declare const createEmitter: <E extends EventMap>() => Emitter<E>;
+/**
+ * Event batching utility for reducing event noise.
+ * This class collects events and emits them in batches.
+ *
+ * @example
+ * const batcher = new EventBatcher(emitter, 'add', 100)
+ * batcher.queue({ value: 1, index: 0 })
+ * batcher.queue({ value: 2, index: 1 })
+ * // After 100ms or flush(), emits single 'batch-add' event with both items
+ */
+export declare class EventBatcher<E extends EventMap, K extends keyof E> {
+  private emitter;
+  private event;
+  private delayMs;
+  private batch;
+  private timer;
+  constructor(emitter: Emitter<E & { [P in `batch-${K & string}`]: E[K][]; }>, event: K, delayMs: number);
+  /**
+   * Add an event to the current batch.
+   */
+  queue(payload: E[K]): void;
+  /**
+   * Immediately emit all batched events.
+   */
+  flush(): void;
+  /**
+   * Clean up resources.
+   */
+  dispose(): void;
+}
+/**
+ * Async event emitter that gives promises.
+ * This class waits for all async listeners to complete.
+ *
+ * @example
+ * const emitter = new AsyncEmitter<{ save: { data: string } }>()
+ *
+ * emitter.on('save', async ({ data }) => {
+ *   await database.save(data)
+ * })
+ *
+ * await emitter.emit('save', { data: 'test' }) // Waits for save
+ */
+export declare class AsyncEmitter<E extends EventMap> {
+  private listeners;
+  on<K extends keyof E>(event: K, listener: Listener<E[K]>): Unsubscribe;
+  /**
+   * Emit an event and wait for all async listeners to complete.
+   *
+   * @param event The event name
+   * @param payload The event payload
+   * @returns Promise that resolves when all listeners complete
+   */
+  emit<K extends keyof E>(event: K, payload: E[K]): Promise<void>;
+  off<K extends keyof E>(event?: K): void;
+  listenerCount<K extends keyof E>(event: K): number;
+  eventNames(): (keyof E)[];
+  dispose(): void;
+}
+/**
+ * Utility to forward events from one emitter to another.
+ * Useful for composing event sources.
+ *
+ * @example
+ * const child = new Emitter<ChildEvents>()
+ * const parent = new Emitter<ParentEvents>()
+ *
+ * forwardEvent(child, parent, 'childEvent', 'parentEvent')
+ */
+export declare const forwardEvent: <E1 extends EventMap, E2 extends EventMap, K1 extends keyof E1, K2 extends keyof E2>(source: Emitter<E1>, target: Emitter<E2>, sourceEvent: K1, targetEvent: K2, transform?: (payload: E1[K1]) => E2[K2]) => Unsubscribe;
+/**
+ * Make a filtered event subscription that only fires when predicate is true.
+ *
+ * @example
+ * const emitter = new Emitter<{ change: { value: number } }>()
+ *
+ * onWhen(emitter, 'change', ({ value }) => value > 10, ({ value }) => {
+ *   console.log('Value exceeded 10:', value)
+ * })
+ */
+export declare const onWhen: <E extends EventMap, K extends keyof E>(emitter: Emitter<E>, event: K, predicate: (payload: E[K]) => boolean, listener: Listener<E[K]>) => Unsubscribe;
+/**
+ * ReadonlyList<T> - Readonly ordered collection with indexed access.
+ *
+ * Mirrors java.util.List but without mutation operations.
+ * Elements maintain their insertion order and can be accessed by index.
+ */
+export interface ReadonlyList<T> extends ReadonlyCollection<T> {
+  /**
+   * This method gives the element at the specified position.
+   *
+   * @param index The index of the element to give (0-based)
+   * @returns The element at the specified position
+   * @throws RangeError if index is out of bounds
+   */
+  get(index: number): T;
+  /**
+   * This method gives the index of the first occurrence of the specified element,
+   * or -1 if not found.
+   *
+   * @param element The element to search for
+   * @param fromIndex Optional starting index for the search
+   */
+  indexOf(element: T, fromIndex?: number): number;
+  /**
+   * This method gives the index of the last occurrence of the specified element,
+   * or -1 if not found.
+   *
+   * @param element The element to search for
+   * @param fromIndex Optional starting index for backwards search
+   */
+  lastIndexOf(element: T, fromIndex?: number): number;
+  /**
+   * This method gives a view of the portion of this list between fromIndex (inclusive)
+   * and toIndex (exclusive).
+   *
+   * Changes to the sublist are reflected in the original list.
+   *
+   * @param fromIndex Start index (inclusive)
+   * @param toIndex End index (exclusive)
+   */
+  subList(fromIndex: number, toIndex: number): ReadonlyList<T>;
+  /**
+   * This method gives the first element in the list.
+   *
+   * @throws Error if list is empty
+   */
+  first(): T;
+  /**
+   * This method gives the last element in the list.
+   *
+   * @throws Error if list is empty
+   */
+  last(): T;
+}
+/**
+ * List<T> - Mutable ordered collection with indexed access.
+ *
+ * Mirrors java.util.List with full mutation capabilities.
+ * This type gives methods to insert, replace, and remove elements by index.
+ */
+export interface List<T> extends ReadonlyList<T>, Collection<T> {
+  /**
+   * This method replaces the element at the specified position.
+   *
+   * @param index The index of the element to replace
+   * @param element The new element
+   * @returns The element previously at the specified position
+   * @throws RangeError if index is out of bounds
+   */
+  set(index: number, element: T): T;
+  /**
+   * This method inserts an element at the specified position.
+   * Shifts elements at and after the position to the right.
+   *
+   * @param index The index at which to insert
+   * @param element The element to insert
+   * @throws RangeError if index is out of bounds (0 to size inclusive)
+   */
+  insert(index: number, element: T): void;
+  /**
+   * This method inserts all elements from the specified collection at the specified position.
+   *
+   * @param index The index at which to insert
+   * @param other The collection whose elements to insert
+   * @returns true if the list changed
+   */
+  insertAll(index: number, other: Iterable<T>): boolean;
+  /**
+   * This method removes the element at the specified position.
+   * Shifts elements after the position to the left.
+   *
+   * @param index The index of the element to remove
+   * @returns The element that was removed
+   * @throws RangeError if index is out of bounds
+   */
+  removeAt(index: number): T;
+  /**
+   * This method removes elements in the specified index range.
+   *
+   * @param fromIndex Start index (inclusive)
+   * @param toIndex End index (exclusive)
+   */
+  removeRange(fromIndex: number, toIndex: number): void;
+  /**
+   * This method sorts this list according to the specified comparator.
+   *
+   * @param compare The comparison function
+   */
+  sort(compare?: Compare<T>): void;
+  /**
+   * This method reverses the order of elements in this list.
+   */
+  reverse(): void;
+  /**
+   * This method gives a mutable sublist view.
+   *
+   * @param fromIndex Start index (inclusive)
+   * @param toIndex End index (exclusive)
+   */
+  subList(fromIndex: number, toIndex: number): List<T>;
+  /**
+   * This method appends an element to the end of this list.
+   * Equivalent to add() but doesn't give boolean.
+   *
+   * @param element The element to append
+   */
+  push(element: T): void;
+  /**
+   * Removes and gives the last element in this list.
+   *
+   * @returns The last element
+   * @throws Error if list is empty
+   */
+  pop(): T;
+  /**
+   * Removes and gives the first element in this list.
+   *
+   * @returns The first element
+   * @throws Error if list is empty
+   */
+  shift(): T;
+  /**
+   * This method prepends an element to the beginning of this list.
+   *
+   * @param element The element to prepend
+   */
+  unshift(element: T): void;
+}
+/**
+ * RandomAccess - Marker interface for lists with O(1) indexed access.
+ *
+ * This type shows that the list gives fast (constant-time) random access.
+ * Examples: ArrayList (yes), LinkedList (no).
+ */
+export interface RandomAccess {
+  /**
+   * This marker property shows random access capability.
+   * Always true for collections implementing this interface.
+   */
+  readonly supportsRandomAccess: true;
+}
+/**
+ * Stack<T> - LIFO (Last-In-First-Out) collection.
+ *
+ * A stack of elements with push/pop operations.
+ * A specialized list or a standalone class can implement this type.
+ */
+export interface Stack<T> extends Iterable<T> {
+  /** Number of elements */
+  readonly size: number;
+  /** True if empty */
+  readonly isEmpty: boolean;
+  /**
+   * This method pushes an element onto the stack.
+   */
+  push(element: T): void;
+  /**
+   * Removes and gives the top element.
+   *
+   * @throws Error if stack is empty
+   */
+  pop(): T;
+  /**
+   * This method gives the top element without removing it.
+   *
+   * @throws Error if stack is empty
+   */
+  peek(): T;
+  /**
+   * This method removes all elements.
+   */
+  clear(): void;
+  /**
+   * This method searches for an element and gives its distance from the top.
+   * This method gives -1 if not found.
+   */
+  search(element: T): number;
+}
+/**
+ * Vector<T> - Synchronized growable array.
+ *
+ * Like ArrayList but with synchronized access.
+ * This interface is a legacy of Java. Use compose(synchronized())(arrayList()) instead.
+ */
+export interface Vector<T> extends List<T> {
+  /**
+   * Current capacity of the underlying array.
+   */
+  readonly capacity: number;
+  /**
+   * Trims capacity to current size to minimize memory usage.
+   */
+  trimToSize(): void;
+  /**
+   * This method increases capacity to make sure that it can hold at least the specified number of elements.
+   */
+  ensureCapacity(minCapacity: number): void;
+}
+/**
+ * CircularList<T> - List with circular/ring buffer behavior.
+ *
+ * When capacity is reached, oldest elements are overwritten.
+ * Useful for fixed-size buffers like logs or history.
+ */
+export interface CircularList<T> extends List<T> {
+  /**
+   * Maximum capacity of the circular list.
+   */
+  readonly capacity: number;
+  /**
+   * This value is true if the list has reached capacity.
+   */
+  readonly isFull: boolean;
+  /**
+   * Number of elements that have been overwritten.
+   */
+  readonly overwriteCount: number;
+}
+/**
+ * Entry<K, V> - An immutable key-value pair from a map.
+ *
+ * Unlike java.util.Map.Entry which has setValue(), our entries are immutable
+ * snapshots. To update a value, use map.set(key, newValue) instead.
+ *
+ * This prevents accidental mutation and makes entries safe to share.
+ */
+export interface Entry<K, V> {
+  readonly key: K;
+  readonly value: V;
+}
+/**
+ * ReadonlyMapLike<K, V> - Readonly key-value mapping.
+ *
+ * This type gives read-only access to map operations.
+ * Note: We use "MapLike" to avoid conflicts with TypeScript's built-in Map type.
+ */
+export interface ReadonlyMapLike<K, V> extends Iterable<Entry<K, V>> {
+  /**
+   * This value is the number of key-value pairs in this map.
+   */
+  readonly size: number;
+  /**
+   * This value is true if this map contains no key-value mappings.
+   */
+  readonly isEmpty: boolean;
+  /**
+   * This method gives true if this map contains a mapping for the specified key.
+   */
+  has(key: K): boolean;
+  /**
+   * This method gives the value to which the specified key is mapped.
+   *
+   * @throws Error if key is not present
+   */
+  get(key: K): V;
+  /**
+   * This method gives the value for the key, or undefined if not present.
+   */
+  getOrUndefined(key: K): V | undefined;
+  /**
+   * This method gives the value for the key, or the default value if not present.
+   */
+  getOrDefault(key: K, defaultValue: V): V;
+  /**
+   * This method gives true if this map maps one or more keys to the specified value.
+   */
+  containsValue(value: V): boolean;
+  /**
+   * This method gives an iterable view of the keys in this map.
+   */
+  keys(): Iterable<K>;
+  /**
+   * This method gives an iterable view of the values in this map.
+   */
+  values(): Iterable<V>;
+  /**
+   * This method gives an iterable view of the key-value pairs in this map.
+   */
+  entries(): Iterable<Entry<K, V>>;
+  /**
+   * This method does the given action for each key-value pair.
+   */
+  forEach(action: (value: V, key: K, map: this) => void): void;
+  /**
+   * This value is the equality function used for keys.
+   */
+  readonly keyEq: Eq<K>;
+  /**
+   * This value is the equality function used for values.
+   */
+  readonly valueEq: Eq<V>;
+}
+/**
+ * MapLike<K, V> - Mutable key-value mapping.
+ *
+ * Mirrors java.util.Map.
+ */
+export interface MapLike<K, V> extends ReadonlyMapLike<K, V> {
+  /**
+   * This method associates the specified value with the specified key in this map.
+   * If the map previously contained a mapping for the key, the old value is replaced.
+   *
+   * @param key The key
+   * @param value The value
+   * @returns The previous value associated with key, or undefined if none
+   */
+  set(key: K, value: V): V | undefined;
+  /**
+   * Associates value with key only if key is not already present.
+   *
+   * @returns The current value (existing or newly set)
+   */
+  setIfAbsent(key: K, value: V): V;
+  /**
+   * This method removes the mapping for a key if it is present.
+   *
+   * @returns The value that was associated with key, or undefined if none
+   */
+  delete(key: K): V | undefined;
+  /**
+   * This method removes the entry for key only if the key has the specified value.
+   *
+   * @returns true if the entry was removed
+   */
+  deleteEntry(key: K, value: V): boolean;
+  /**
+   * This method replaces the entry for key only if the key has a value.
+   *
+   * @returns The previous value, or undefined if key was not present
+   */
+  replace(key: K, value: V): V | undefined;
+  /**
+   * This method replaces the entry for key only if the key has the specified oldValue.
+   *
+   * @returns true if the value was replaced
+   */
+  replaceEntry(key: K, oldValue: V, newValue: V): boolean;
+  /**
+   * If the specified key is not already associated with a value,
+   * computes its value using the given function and enters it into the map.
+   *
+   * @returns The current (existing or computed) value associated with the key
+   */
+  computeIfAbsent(key: K, mappingFunction: (key: K) => V): V;
+  /**
+   * If the value for the specified key is present, tries to compute
+   * a new mapping given the key and its current mapped value.
+   *
+   * @returns The new value associated with the key, or undefined if none
+   */
+  computeIfPresent(key: K, remappingFunction: (key: K, value: V) => V | undefined): V | undefined;
+  /**
+   * This method tries to compute a mapping for the specified key and its current mapped value.
+   *
+   * @returns The new value associated with the key, or undefined if none
+   */
+  compute(key: K, remappingFunction: (key: K, value: V | undefined) => V | undefined): V | undefined;
+  /**
+   * If the specified key is not already associated with a value or is
+   * associated with undefined, associates it with the given non-undefined value.
+   * Otherwise, replaces the value with the results of the given remapping function.
+   *
+   * @returns The new value associated with the key, or undefined if none
+   */
+  merge(key: K, value: V, remappingFunction: (oldValue: V, newValue: V) => V | undefined): V | undefined;
+  /**
+   * This method copies all mappings from the specified map to this map.
+   */
+  putAll(other: ReadonlyMapLike<K, V> | Iterable<Entry<K, V>>): void;
+  /**
+   * This method removes all mappings from this map.
+   */
+  clear(): void;
+}
+/**
+ * SortedMap<K, V> - Map that maintains keys in sorted order.
+ *
+ * Mirrors java.util.SortedMap.
+ */
+export interface SortedMap<K, V> extends MapLike<K, V> {
+  /**
+   * This value is the comparison function used to order keys.
+   */
+  readonly comparator: Compare<K>;
+  /**
+   * This method gives the first (lowest) key in this map.
+   *
+   * @throws Error if map is empty
+   */
+  firstKey(): K;
+  /**
+   * This method gives the last (highest) key in this map.
+   *
+   * @throws Error if map is empty
+   */
+  lastKey(): K;
+  /**
+   * This method gives a view of the portion of this map whose keys are less than toKey.
+   */
+  headMap(toKey: K): SortedMap<K, V>;
+  /**
+   * This method gives a view of the portion of this map whose keys are greater than or equal to fromKey.
+   */
+  tailMap(fromKey: K): SortedMap<K, V>;
+  /**
+   * This method gives a view of the portion of this map whose keys range from fromKey to toKey.
+   */
+  subMap(fromKey: K, toKey: K): SortedMap<K, V>;
+}
+/**
+ * NavigableMap<K, V> - Extended sorted map with navigation methods.
+ *
+ * Mirrors java.util.NavigableMap.
+ */
+export interface NavigableMap<K, V> extends SortedMap<K, V> {
+  /**
+   * This method gives the greatest key less than or equal to the given key, or undefined if none.
+   */
+  floorKey(key: K): K | undefined;
+  /**
+   * This method gives the least key greater than or equal to the given key, or undefined if none.
+   */
+  ceilingKey(key: K): K | undefined;
+  /**
+   * This method gives the greatest key strictly less than the given key, or undefined if none.
+   */
+  lowerKey(key: K): K | undefined;
+  /**
+   * This method gives the least key strictly greater than the given key, or undefined if none.
+   */
+  higherKey(key: K): K | undefined;
+  /**
+   * This method gives the entry for the greatest key less than or equal to the given key, or undefined.
+   */
+  floorEntry(key: K): Entry<K, V> | undefined;
+  /**
+   * This method gives the entry for the least key greater than or equal to the given key, or undefined.
+   */
+  ceilingEntry(key: K): Entry<K, V> | undefined;
+  /**
+   * This method gives the entry for the greatest key strictly less than the given key, or undefined.
+   */
+  lowerEntry(key: K): Entry<K, V> | undefined;
+  /**
+   * This method gives the entry for the least key strictly greater than the given key, or undefined.
+   */
+  higherEntry(key: K): Entry<K, V> | undefined;
+  /**
+   * This method gives the first (lowest) entry in this map, or undefined if empty.
+   */
+  firstEntry(): Entry<K, V> | undefined;
+  /**
+   * This method gives the last (highest) entry in this map, or undefined if empty.
+   */
+  lastEntry(): Entry<K, V> | undefined;
+  /**
+   * Removes and gives the first (lowest) entry, or undefined if empty.
+   */
+  pollFirstEntry(): Entry<K, V> | undefined;
+  /**
+   * Removes and gives the last (highest) entry, or undefined if empty.
+   */
+  pollLastEntry(): Entry<K, V> | undefined;
+  /**
+   * This method gives a reverse order view of this map.
+   */
+  descendingMap(): NavigableMap<K, V>;
+  /**
+   * This method gives a reverse order iterable of the keys.
+   */
+  descendingKeys(): Iterable<K>;
+}
+/**
+ * MultiMap<K, V> - Map that can hold multiple values per key.
+ *
+ * Not in standard Java Collections, but commonly used.
+ */
+export interface MultiMap<K, V> {
+  readonly size: number;
+  readonly isEmpty: boolean;
+  /**
+   * This method gives true if the map contains at least one value for the key.
+   */
+  has(key: K): boolean;
+  /**
+   * This method gives all values associated with the key.
+   */
+  get(key: K): ReadonlyCollection<V>;
+  /**
+   * This method adds a value to the collection of values for the key.
+   */
+  put(key: K, value: V): boolean;
+  /**
+   * This method adds all values to the collection of values for the key.
+   */
+  putAll(key: K, values: Iterable<V>): boolean;
+  /**
+   * This method removes a single occurrence of value from the key's collection.
+   */
+  remove(key: K, value: V): boolean;
+  /**
+   * This method removes all values for the key.
+   */
+  removeAll(key: K): ReadonlyCollection<V>;
+  /**
+   * This method replaces all values for the key with the given values.
+   */
+  replaceAll(key: K, values: Iterable<V>): ReadonlyCollection<V>;
+  /**
+   * This method gives all keys that have at least one value.
+   */
+  keys(): Iterable<K>;
+  /**
+   * This method gives all entries (key with one of its values).
+   */
+  entries(): Iterable<Entry<K, V>>;
+  /**
+   * This method removes all mappings.
+   */
+  clear(): void;
+}
+/**
+ * BiMap<K, V> - Bidirectional map (1:1 mapping).
+ *
+ * Both keys and values are unique.
+ * With this type, lookup is by key or by value.
+ */
+export interface BiMap<K, V> extends MapLike<K, V> {
+  /**
+   * This method gives the inverse view of this bimap (swaps keys and values).
+   */
+  inverse(): BiMap<V, K>;
+  /**
+   * This method gives the key mapped to the specified value, or undefined if none.
+   */
+  getKey(value: V): K | undefined;
+  /**
+   * This method forces the put by removing any existing entry with the same value.
+   */
+  forcePut(key: K, value: V): V | undefined;
+}
+/**
+ * WeakMapLike<K extends object, V> - Map with weak key references.
+ *
+ * Mirrors JavaScript's WeakMap but with our interface conventions.
+ * Keys must be objects and are held weakly (so garbage collection can remove them).
+ */
+export interface WeakMapLike<K extends object, V> {
+  has(key: K): boolean;
+  get(key: K): V | undefined;
+  set(key: K, value: V): this;
+  delete(key: K): boolean;
+}
+/**
+ * ReadonlySet<T> - Readonly set with no duplicates.
+ */
+export interface ReadonlySet<T> extends ReadonlyCollection<T> {
+  /**
+   * This method gives true if this set contains the specified element.
+   */
+  contains(element: T): boolean;
+  /**
+   * This method gives true if this set contains all elements in the specified collection.
+   */
+  containsAll(other: Iterable<T>): boolean;
+}
+/**
+ * Set<T> - Mutable set with no duplicates.
+ *
+ * Mirrors java.util.Set.
+ * Elements are unique based on the set's equality function.
+ */
+interface Set$1<T> extends ReadonlySet<T>, Collection<T> {
+  /**
+   * This method adds the specified element to this set if it is not already present.
+   *
+   * @returns true if this set did not already contain the element
+   */
+  add(element: T): boolean;
+  /**
+   * This method removes the specified element from this set if it is present.
+   *
+   * @returns true if this set contained the element
+   */
+  remove(element: T): boolean;
+  /**
+   * This method adds all elements in the specified collection to this set.
+   * This is a union operation.
+   *
+   * @returns true if this set changed
+   */
+  addAll(other: Iterable<T>): boolean;
+  /**
+   * This method removes from this set all of its elements that are contained in the specified collection.
+   * This is a difference operation.
+   *
+   * @returns true if this set changed
+   */
+  removeAll(other: Iterable<T>): boolean;
+  /**
+   * This method retains only the elements in this set that are contained in the specified collection.
+   * This is an intersection operation.
+   *
+   * @returns true if this set changed
+   */
+  retainAll(other: Iterable<T>): boolean;
+}
+/**
+ * SortedSet<T> - Set that maintains elements in sorted order.
+ *
+ * Mirrors java.util.SortedSet.
+ */
+export interface SortedSet<T> extends Set$1<T> {
+  /**
+   * This value is the comparator used to order elements in this set.
+   */
+  readonly comparator: Compare<T>;
+  /**
+   * This method gives the first (lowest) element in this set.
+   *
+   * @throws Error if set is empty
+   */
+  first(): T;
+  /**
+   * This method gives the last (highest) element in this set.
+   *
+   * @throws Error if set is empty
+   */
+  last(): T;
+  /**
+   * This method gives a view of the portion of this set whose elements are strictly less than toElement.
+   */
+  headSet(toElement: T): SortedSet<T>;
+  /**
+   * This method gives a view of the portion of this set whose elements are greater than or equal to fromElement.
+   */
+  tailSet(fromElement: T): SortedSet<T>;
+  /**
+   * This method gives a view of the portion of this set whose elements range from fromElement to toElement.
+   */
+  subSet(fromElement: T, toElement: T): SortedSet<T>;
+}
+/**
+ * NavigableSet<T> - Extended sorted set with navigation methods.
+ *
+ * Mirrors java.util.NavigableSet.
+ */
+export interface NavigableSet<T> extends SortedSet<T> {
+  /**
+   * This method gives the greatest element less than or equal to the given element, or undefined if none.
+   */
+  floor(element: T): T | undefined;
+  /**
+   * This method gives the least element greater than or equal to the given element, or undefined if none.
+   */
+  ceiling(element: T): T | undefined;
+  /**
+   * This method gives the greatest element strictly less than the given element, or undefined if none.
+   */
+  lower(element: T): T | undefined;
+  /**
+   * This method gives the least element strictly greater than the given element, or undefined if none.
+   */
+  higher(element: T): T | undefined;
+  /**
+   * Retrieves and removes the first (lowest) element, or gives undefined if empty.
+   */
+  pollFirst(): T | undefined;
+  /**
+   * Retrieves and removes the last (highest) element, or gives undefined if empty.
+   */
+  pollLast(): T | undefined;
+  /**
+   * This method gives a reverse order view of this set.
+   */
+  descendingSet(): NavigableSet<T>;
+  /**
+   * This method gives a reverse order iterator over the elements in this set.
+   */
+  descendingIterator(): Iterator<T>;
+}
+/**
+ * A set of listeners for the events of a storage: the change batches of `observe()`, or the status
+ * of a sync. A storage package uses it, so each storage treats its listeners in the same way.
+ */
+/** The function that gets the error of a listener. */
+type ListenerErrorHandler = (error: unknown) => void;
+/**
+ * The default handler of the error of a listener. It throws the error again in a microtask, as an
+ * `EventTarget` reports the error of a listener. Thus the error is not lost, and the write that
+ * sent the event does not fail.
+ */
+export declare const reportListenerError: ListenerErrorHandler;
+/**
+ * The listeners of one kind of event.
+ *
+ * - `emit()` gives the event to each listener, in the order of `add()`.
+ * - A listener that `add()` gets during an `emit()` gets the next event, not this one.
+ * - The error of a listener goes to the error handler. The other listeners get the event.
+ * - The same function can be added two times. Each `add()` gives its own function that removes it.
+ */
+export declare class StorageListeners<E> {
+  private readonly listeners;
+  private readonly onError;
+  /** @param onError - The function that gets the error of a listener. The default is `reportListenerError`. */
+  constructor(onError?: ListenerErrorHandler);
+  /** The number of listeners. */
+  get size(): number;
+  /**
+   * This method adds a listener.
+   *
+   * @returns The function that removes the listener. A second use of it does nothing.
+   */
+  add(listener: (event: E) => void): () => void;
+  /** This method gives the event to each listener. */
+  emit(event: E): void;
+  /** This method removes each listener. */
+  clear(): void;
+}
+/**
+ * The keys of an ordered list: fractional indexing with base-62 keys. A
+ * key is a string. Each item of the list keeps one, and the list sorts by it. An item that moves
+ * between two others gets a key between theirs, so a move writes one item and no other.
+ *
+ * - A key has an integer part and a fraction part. The first character of the integer part gives its
+ *   length. An insertion at an end changes the integer part, so the keys stay short.
+ * - An insertion between two keys uses the fraction part, which can grow without a limit. Thus the keys
+ *   do not run out, and the list needs no rebalance.
+ * - Compare two keys by the code units of the strings (`a < b`), not with `localeCompare`.
+ * - Two writers that move items into the same gap at the same time can get the same key. Sort by the
+ *   key, then by the id of the item, so each reader sees one order.
+ *
+ * The algorithm is the one of the `fractional-indexing` package of Rocicorp (CC0), after the article
+ * "Implementing Fractional Indexing" of David Greenspan.
+ */
+/** The digits of a key, in ascending order of their code units. */
+export declare const KEY_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+/**
+ * This function gives a key strictly between two keys. Without `prev`, the key comes before `next`.
+ * Without `next`, it comes after `prev`. Without both, it gives the first key of a list ("a0").
+ *
+ * @throws RangeError when a key is not valid, or when `prev` is not before `next`
+ *
+ * @example
+ * ```ts
+ * keyBetween(undefined, undefined); // "a0"
+ * keyBetween("a0", undefined); // "a1", after a0
+ * keyBetween("a0", "a1"); // "a0V"
+ * ```
+ */
+export declare function keyBetween(prev: string | null | undefined, next: string | null | undefined): string;
+/**
+ * This function gives `count` keys in ascending order, strictly between two keys.
+ * Use it to put several items at one place, or to give keys to a new list.
+ *
+ * @throws RangeError as `keyBetween`, or when `count` is not an integer of 0 or more
+ */
+export declare function keysBetween(prev: string | null | undefined, next: string | null | undefined, count: number): string[];
+/** The options of `isValidKey`. */
+interface KeyCheckOptions {
+  /** The longest key that the check accepts. The default is 1024 characters. */
+  readonly maxLength?: number;
+}
+/**
+ * This function tells if a value is a valid key, for example a key that a client writes. A key that
+ * is longer than `maxLength` is not valid.
+ */
+export declare function isValidKey(key: unknown, options?: KeyCheckOptions): key is string;
+/** An item of an ordered list: its id and its key. */
+interface KeyedItem {
+  readonly id: string;
+  readonly key: string;
+}
+/**
+ * This function gives the writes of a move: the new key of the item that moves, and new keys for the
+ * neighbors that need them. Give the other items of the list in order (by key, then by id), without
+ * the item that moves. Also give the index of the drop, from 0 to their number (`dropIndex`).
+ *
+ * Two writers can give two items one key. A drop between two such items has no key between them.
+ * So the helper first gives new keys to the items after the drop that have the key of the item before
+ * it. Each write is `{ id, key }`. The writes of the neighbors come first, and the write of the item
+ * that moves comes last.
+ *
+ * @throws RangeError when the index is outside the list, when the list holds the item that moves, or
+ * when a key is not valid
+ *
+ * @example
+ * ```ts
+ * const index = dropIndex(pointer, others.map(centerOf));
+ * for (const { id, key } of keysForDrop(others, index, dragged.id)) await save(id, { rank: key });
+ * ```
+ */
+export declare function keysForDrop(items: readonly KeyedItem[], index: number, movingId: string): Array<{
+  id: string;
+  key: string;
+}>;
+/** The order of two keys: the code units of the strings, as the keys need (not `localeCompare`). */
+export declare function compareKeys(a: string, b: string): number;
+/** A point, for example the center of an item on the screen. */
+interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+/**
+ * This function gives the index at which a point goes among the items of a list on the screen.
+ * The reading order is the rows from top to bottom, and each row from left to right.
+ * The index is that of the first item whose center comes after the point, from 0 to the number of items. A center within
+ * `rowTolerance` of the point on the vertical axis is in the row of the point.
+ *
+ * Give the centers in reading order, the same order as the keys, and without the item that moves.
+ *
+ * @example
+ * ```ts
+ * const index = dropIndex(pointer, others.map(centerOf));
+ * const key = keyBetween(keys[index - 1], keys[index]);
+ * ```
+ */
+export declare function dropIndex(point: Point, centers: readonly Point[], rowTolerance?: number): number;
+/**
+ * ReadonlyQueue<T> - Readonly FIFO (First-In-First-Out) queue.
+ *
+ * This type gives read-only access to queue operations.
+ */
+interface ReadonlyQueue<T> extends ReadonlyCollection<T> {
+  /**
+   * Retrieves, but does not remove, the head of this queue.
+   *
+   * @returns The head element
+   * @throws Error if queue is empty
+   */
+  peek(): T;
+  /**
+   * This method gives the head element without throwing if empty.
+   * This method gives undefined if queue is empty.
+   */
+  peekOrUndefined(): T | undefined;
+}
+/**
+ * Queue<T> - FIFO (First-In-First-Out) queue.
+ *
+ * Mirrors java.util.Queue.
+ * Elements are processed in the order they were added.
+ */
+interface Queue<T> extends ReadonlyQueue<T>, Collection<T> {
+  /**
+   * This method inserts an element into the queue.
+   * For bounded queues with overflow='throw', throws if queue is full.
+   *
+   * @param element The element to add
+   * @returns true if element was added
+   * @throws Error if queue is full (bounded with throw policy)
+   */
+  offer(element: T): boolean;
+  /**
+   * Retrieves and removes the head of this queue.
+   *
+   * @returns The head element
+   * @throws Error if queue is empty
+   */
+  poll(): T;
+  /**
+   * Retrieves and removes the head of this queue, or gives undefined if empty.
+   */
+  pollOrUndefined(): T | undefined;
+  /**
+   * Alias for offer(). This method adds element to end of queue.
+   * This method is here for consistency with standard queue terminology.
+   */
+  enqueue(element: T): boolean;
+  /**
+   * Alias for poll(). Removes and gives element from front of queue.
+   * This method is here for consistency with standard queue terminology.
+   */
+  dequeue(): T;
+}
+/**
+ * Deque<T> - Double-ended queue.
+ *
+ * Mirrors java.util.Deque.
+ * This type supports insertion and removal at both ends.
+ * This type operates as a queue (FIFO) or a stack (LIFO).
+ */
+interface Deque<T> extends Queue<T> {
+  /**
+   * This method inserts element at the front of this deque.
+   *
+   * @param element The element to add
+   * @throws Error if deque is full (bounded with throw policy)
+   */
+  addFirst(element: T): void;
+  /**
+   * This method inserts element at the front, giving false if full.
+   */
+  offerFirst(element: T): boolean;
+  /**
+   * Retrieves and removes the first element.
+   *
+   * @throws Error if deque is empty
+   */
+  removeFirst(): T;
+  /**
+   * Retrieves and removes the first element, or undefined if empty.
+   */
+  pollFirst(): T | undefined;
+  /**
+   * Retrieves but does not remove the first element.
+   *
+   * @throws Error if deque is empty
+   */
+  peekFirst(): T;
+  /**
+   * Retrieves but does not remove the first element, or undefined if empty.
+   */
+  peekFirstOrUndefined(): T | undefined;
+  /**
+   * This method inserts element at the end of this deque.
+   *
+   * @param element The element to add
+   * @throws Error if deque is full (bounded with throw policy)
+   */
+  addLast(element: T): void;
+  /**
+   * This method inserts element at the end, giving false if full.
+   */
+  offerLast(element: T): boolean;
+  /**
+   * Retrieves and removes the last element.
+   *
+   * @throws Error if deque is empty
+   */
+  removeLast(): T;
+  /**
+   * Retrieves and removes the last element, or undefined if empty.
+   */
+  pollLast(): T | undefined;
+  /**
+   * Retrieves but does not remove the last element.
+   *
+   * @throws Error if deque is empty
+   */
+  peekLast(): T;
+  /**
+   * Retrieves but does not remove the last element, or undefined if empty.
+   */
+  peekLastOrUndefined(): T | undefined;
+  /**
+   * This method pushes element onto the stack represented by this deque.
+   * Equivalent to addLast().
+   *
+   * @param element The element to push
+   */
+  push(element: T): void;
+  /**
+   * This method pops an element from the stack represented by this deque.
+   * Equivalent to removeLast().
+   *
+   * @returns The popped element
+   * @throws Error if deque is empty
+   */
+  pop(): T;
+}
+/**
+ * BlockingQueue<T> - Queue that supports blocking operations.
+ *
+ * Mirrors java.util.concurrent.BlockingQueue.
+ * Useful for producer-consumer patterns.
+ */
+interface BlockingQueue<T> extends Queue<T> {
+  /**
+   * This method inserts element, waiting if necessary for space to become available.
+   *
+   * @param element The element to add
+   * @param timeoutMs Optional timeout in milliseconds
+   * @returns Promise that resolves to true when element is added
+   * @throws Error if timeout expires
+   */
+  put(element: T, timeoutMs?: number): Promise<void>;
+  /**
+   * Retrieves and removes the head, waiting if necessary until an element is available.
+   *
+   * @param timeoutMs Optional timeout in milliseconds
+   * @returns Promise that resolves to the head element
+   * @throws Error if timeout expires
+   */
+  take(timeoutMs?: number): Promise<T>;
+  /**
+   * This value is the remaining capacity.
+   * This value is Infinity for unbounded queues.
+   */
+  readonly remainingCapacity: number;
+  /**
+   * This method removes all available elements and adds them to the given array.
+   * This method gives the number of elements transferred.
+   */
+  drainTo(target: T[], maxElements?: number): number;
+}
+/**
+ * PriorityQueue<T> - Queue that orders elements by priority.
+ *
+ * Mirrors java.util.PriorityQueue.
+ * Elements are removed in priority order (not insertion order).
+ * A comparison function is necessary for this type to determine priority.
+ */
+interface PriorityQueue<T> extends Queue<T> {
+  /**
+   * The comparison function used to determine priority.
+   * Elements with lower compare value have higher priority.
+   */
+  readonly compare: Compare<T>;
+  /**
+   * This value is the comparator used to order elements, or undefined if natural ordering.
+   */
+  readonly comparator: Compare<T> | undefined;
+}
+/**
+ * AsyncQueue<T> - Async iterable queue.
+ *
+ * This type is for async/await patterns and streaming data.
+ * This type implements AsyncIterable for use with for-await-of loops.
+ */
+interface AsyncQueue$1<T> extends AsyncIterable<T> {
+  /** This value is the number of elements in the queue. */
+  readonly size: number;
+  /** True if queue is empty */
+  readonly isEmpty: boolean;
+  /**
+   * This method adds element to queue.
+   * For bounded queues, this method can wait for space to become available.
+   */
+  put(element: T): Promise<void>;
+  /**
+   * Removes and gives next element.
+   * Waits for an element if queue is empty.
+   */
+  take(): Promise<T>;
+  /**
+   * This method tries to add element without waiting.
+   * This method gives false if queue is full.
+   */
+  tryPut(element: T): boolean;
+  /**
+   * This method tries to remove element without waiting.
+   * This method gives undefined if queue is empty.
+   */
+  tryTake(): T | undefined;
+  /**
+   * This method gives next element without removing it.
+   * Waits for an element if queue is empty.
+   */
+  peek(): Promise<T>;
+  /**
+   * This method closes the queue, preventing further additions.
+   * After this method, consumers can still take the existing elements.
+   */
+  close(): void;
+  /**
+   * This value is true if queue is closed.
+   */
+  readonly isClosed: boolean;
+}
+/**
+ * TransferQueue<T> - Queue where producers can wait for consumers.
+ *
+ * Mirrors java.util.concurrent.TransferQueue.
+ * Useful for direct handoff between producer and consumer threads.
+ */
+interface TransferQueue<T> extends BlockingQueue<T> {
+  /**
+   * Transfers element to consumer, waiting if necessary.
+   * This method waits for a consumer to receive the element.
+   *
+   * @param element The element to transfer
+   * @returns Promise that resolves when element is received
+   */
+  transfer(element: T): Promise<void>;
+  /**
+   * This method tries to transfer element to waiting consumer.
+   * This method gives false immediately if no consumer is waiting.
+   *
+   * @param element The element to transfer
+   * @param timeoutMs Optional timeout in milliseconds
+   */
+  tryTransfer(element: T, timeoutMs?: number): Promise<boolean>;
+  /**
+   * This value is true if there are consumers waiting to receive elements.
+   */
+  readonly hasWaitingConsumer: boolean;
+  /**
+   * This value is an estimate of the number of consumers waiting to receive elements.
+   */
+  readonly waitingConsumerCount: number;
+}
+/**
+ * DelayQueue<T> - Queue where elements become available after a delay.
+ *
+ * Mirrors java.util.concurrent.DelayQueue.
+ * Elements can only be removed once their delay has expired.
+ */
+interface DelayQueue<T> extends BlockingQueue<T> {
+  /**
+   * This method adds element with specified delay.
+   *
+   * @param element The element to add
+   * @param delayMs Delay in milliseconds before element becomes available (defaults to 0)
+   */
+  offer(element: T, delayMs?: number): boolean;
+  /**
+   * This value is the delay (in ms) until next element becomes available.
+   * The delay is `0` when the element is available.
+   * This value is Infinity if queue is empty.
+   */
+  readonly nextDelay: number;
+}
+/**
+ * Options for making an ArrayList.
+ */
+export interface ArrayListOptions<T> {
+  /**
+   * Initial capacity of the underlying array.
+   * @default 10
+   */
+  initialCapacity?: number;
+  /**
+   * Equality function for comparing elements.
+   * @default defaultEq (===)
+   */
+  eq?: Eq<T>;
+}
+/**
+ * ArrayList<T> - Resizable array implementation of the List interface.
+ *
+ * This class gives fast random access (O(1)) and fast append (amortized O(1)).
+ * Insertion and removal in the middle shift elements (O(n)).
+ *
+ * This is the most commonly used list implementation.
+ */
+export declare class ArrayList<T> implements List<T>, RandomAccess {
+  private _array;
+  private _size;
+  private readonly _eq;
+  readonly supportsRandomAccess: true;
+  constructor(options?: ArrayListOptions<T>);
+  get size(): number;
+  get isEmpty(): boolean;
+  /**
+   * Current capacity of the underlying array.
+   */
+  get capacity(): number;
+  get eq(): Eq<T>;
+  get(index: number): T;
+  set(index: number, element: T): T;
+  contains(element: T): boolean;
+  indexOf(element: T, fromIndex?: number): number;
+  lastIndexOf(element: T, fromIndex?: number): number;
+  containsAll(other: Iterable<T>): boolean;
+  add(element: T): boolean;
+  push(element: T): void;
+  unshift(element: T): void;
+  insert(index: number, element: T): void;
+  insertAll(index: number, other: Iterable<T>): boolean;
+  addAll(other: Iterable<T>): boolean;
+  remove(element: T): boolean;
+  removeAt(index: number): T;
+  pop(): T;
+  shift(): T;
+  removeRange(fromIndex: number, toIndex: number): void;
+  removeAll(other: Iterable<T>): boolean;
+  retainAll(other: Iterable<T>): boolean;
+  clear(): void;
+  sort(compare?: Compare<T>): void;
+  reverse(): void;
+  first(): T;
+  last(): T;
+  subList(fromIndex: number, toIndex: number): List<T>;
+  [Symbol.iterator](): Iterator<T>;
+  forEach(action: (element: T, index: number) => void): void;
+  toArray(): T[];
+  /**
+   * This method makes sure that the capacity is at least the specified minimum.
+   */
+  ensureCapacity(minCapacity: number): void;
+  /**
+   * This method trims the capacity to the current size to minimize memory usage.
+   */
+  trimToSize(): void;
+  private checkIndex;
+  private checkInsertIndex;
+  private checkRange;
+}
+/**
+ * Factory function to make an ArrayList.
+ *
+ * @example
+ * const list = arrayList<number>()
+ * const listWithEq = arrayList<User>({ eq: (a, b) => a.id === b.id })
+ * const listFromArray = arrayList([1, 2, 3])
+ */
+export declare function arrayList<T>(optionsOrElements?: ArrayListOptions<T> | Iterable<T>): ArrayList<T>;
+/**
+ * Options for making an ArrayDeque.
+ */
+export interface ArrayDequeOptions<T> {
+  /**
+   * Initial capacity of the underlying array.
+   * This value must be a power of 2 for efficient modulo operations.
+   * @default 16
+   */
+  initialCapacity?: number;
+  /**
+   * Equality function for comparing elements.
+   * @default defaultEq (===)
+   */
+  eq?: Eq<T>;
+}
+/**
+ * ArrayDeque<T> - Ring buffer implementation of Deque.
+ *
+ * This class uses a circular array to give O(1) operations at both ends.
+ * The array grows automatically when full.
+ *
+ * Not thread-safe. Use synchronized() behavior for concurrent access.
+ */
+export declare class ArrayDeque<T> implements Deque<T> {
+  private _elements;
+  private _head;
+  private _tail;
+  private readonly _eq;
+  constructor(options?: ArrayDequeOptions<T>);
+  get size(): number;
+  get isEmpty(): boolean;
+  get eq(): Eq<T>;
+  addFirst(element: T): void;
+  offerFirst(element: T): boolean;
+  removeFirst(): T;
+  pollFirst(): T | undefined;
+  peekFirst(): T;
+  peekFirstOrUndefined(): T | undefined;
+  addLast(element: T): void;
+  offerLast(element: T): boolean;
+  removeLast(): T;
+  pollLast(): T | undefined;
+  peekLast(): T;
+  peekLastOrUndefined(): T | undefined;
+  push(element: T): void;
+  pop(): T;
+  offer(element: T): boolean;
+  poll(): T;
+  peek(): T;
+  peekOrUndefined(): T | undefined;
+  pollOrUndefined(): T | undefined;
+  enqueue(element: T): boolean;
+  dequeue(): T;
+  add(element: T): boolean;
+  addAll(other: Iterable<T>): boolean;
+  contains(element: T): boolean;
+  containsAll(other: Iterable<T>): boolean;
+  remove(element: T): boolean;
+  /**
+   * This method removes the element at a position from the head. The shorter side moves one place.
+   * (Before, a bitwise expression chose the side, and it was not a valid test.)
+   */
+  private removeAtOffset;
+  removeAll(other: Iterable<T>): boolean;
+  retainAll(other: Iterable<T>): boolean;
+  clear(): void;
+  [Symbol.iterator](): Iterator<T>;
+  forEach(action: (element: T, index: number) => void): void;
+  toArray(): T[];
+  /**
+   * This method doubles the capacity of the deque.
+   */
+  private grow;
+  /**
+   * This method gives the next power of 2 >= n.
+   */
+  private nextPowerOfTwo;
+  /**
+   * This value is the current capacity of the underlying array.
+   */
+  get capacity(): number;
+  /**
+   * This method gives a string representation for debugging.
+   */
+  toString(): string;
+}
+/**
+ * Factory function to make an ArrayDeque.
+ *
+ * @example
+ * const deque = arrayDeque<number>()
+ * const dequeFromArray = arrayDeque([1, 2, 3])
+ * const dequeWithOptions = arrayDeque<string>({ initialCapacity: 32 })
+ */
+export declare function arrayDeque<T>(optionsOrElements?: ArrayDequeOptions<T> | Iterable<T>): ArrayDeque<T>;
+/**
+ * Options for making a HashMap.
+ */
+export interface HashMapOptions<K, V> {
+  /**
+   * Initial capacity (number of buckets).
+   * This value must be a power of 2.
+   * @default 16
+   */
+  initialCapacity?: number;
+  /**
+   * Load factor threshold for resizing (0-1).
+   * When size > capacity * loadFactor, the map resizes.
+   * @default 0.75
+   */
+  loadFactor?: number;
+  /**
+   * Equality function for keys.
+   * @default defaultEq (===)
+   */
+  keyEq?: Eq<K>;
+  /**
+   * Hash function for keys.
+   * @default defaultHash
+   */
+  keyHash?: Hash<K>;
+  /**
+   * Equality function for values (used in containsValue).
+   * @default defaultEq (===)
+   */
+  valueEq?: Eq<V>;
+}
+/**
+ * HashMap<K, V> - Hash table implementation with custom equality/hashing.
+ *
+ * This class uses separate chaining for collision resolution.
+ * Automatically resizes when load factor is exceeded.
+ *
+ * Not thread-safe. Use synchronized() behavior for concurrent access.
+ */
+export declare class HashMap<K, V> implements MapLike<K, V> {
+  private _buckets;
+  private _size;
+  private readonly _loadFactor;
+  private readonly _keyEq;
+  private readonly _keyHash;
+  private readonly _valueEq;
+  private _threshold;
+  /**
+   * The count of structural changes (a key added or removed, a clear, a resize). An iterator
+   * records it at its start and throws when it changes. Before, a resize during iteration made
+   * the iterator skip or repeat entries (BUGS-2026-07 L15).
+   */
+  private _modCount;
+  constructor(options?: HashMapOptions<K, V>);
+  get size(): number;
+  get isEmpty(): boolean;
+  get keyEq(): Eq<K>;
+  get valueEq(): Eq<V>;
+  has(key: K): boolean;
+  get(key: K): V;
+  getOrUndefined(key: K): V | undefined;
+  getOrDefault(key: K, defaultValue: V): V;
+  containsValue(value: V): boolean;
+  set(key: K, value: V): V | undefined;
+  setIfAbsent(key: K, value: V): V;
+  delete(key: K): V | undefined;
+  deleteEntry(key: K, value: V): boolean;
+  replace(key: K, value: V): V | undefined;
+  replaceEntry(key: K, oldValue: V, newValue: V): boolean;
+  computeIfAbsent(key: K, mappingFunction: (key: K) => V): V;
+  computeIfPresent(key: K, remappingFunction: (key: K, value: V) => V | undefined): V | undefined;
+  compute(key: K, remappingFunction: (key: K, value: V | undefined) => V | undefined): V | undefined;
+  merge(key: K, value: V, remappingFunction: (oldValue: V, newValue: V) => V | undefined): V | undefined;
+  putAll(other: MapLike<K, V> | Iterable<Entry<K, V>>): void;
+  clear(): void;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<Entry<K, V>>;
+  [Symbol.iterator](): Iterator<Entry<K, V>>;
+  forEach(action: (value: V, key: K, map: this) => void): void;
+  /** This method throws when the map changed structurally after an iterator started. */
+  private checkUnchanged;
+  /**
+   * This method gives the bucket index for a given hash.
+   */
+  private bucketIndex;
+  /**
+   * This method resizes the hash table to double its current capacity.
+   */
+  private resize;
+  /**
+   * This method gives the next power of 2 >= n.
+   */
+  private nextPowerOfTwo;
+  /**
+   * This value is the current number of buckets.
+   */
+  get capacity(): number;
+  /**
+   * This value is the current load factor (size / capacity).
+   */
+  get loadFactor(): number;
+  /**
+   * This method gives statistics about bucket distribution (for debugging).
+   */
+  getStats(): {
+    size: number;
+    capacity: number;
+    loadFactor: number;
+    avgChainLength: number;
+    maxChainLength: number;
+    emptyBuckets: number;
+  };
+}
+/**
+ * Factory function to make a HashMap.
+ *
+ * @example
+ * const map = hashMap<string, number>()
+ * const mapWithOptions = hashMap<User, Data>({
+ *   keyEq: (a, b) => a.id === b.id,
+ *   keyHash: (u) => hashString(u.id)
+ * })
+ * const mapFromEntries = hashMap([['a', 1], ['b', 2]])
+ */
+export declare function hashMap<K, V>(optionsOrEntries?: HashMapOptions<K, V> | Iterable<readonly [K, V]>): HashMap<K, V>;
+/**
+ * Options for making a LinkedHashMap.
+ */
+export interface LinkedHashMapOptions<K, V> {
+  /**
+   * Initial capacity of the hash table.
+   * @default 16
+   */
+  initialCapacity?: number;
+  /**
+   * Load factor before resizing.
+   * @default 0.75
+   */
+  loadFactor?: number;
+  /**
+   * Equality function for keys.
+   * @default defaultEq
+   */
+  eq?: Eq<K>;
+  /**
+   * Hash function for keys.
+   * @default defaultHash
+   */
+  hash?: Hash<K>;
+  /**
+   * Equality function for values.
+   * @default defaultEq
+   */
+  valueEq?: Eq<V>;
+  /**
+   * If true, maintain access order instead of insertion order.
+   * Useful for LRU caches.
+   * @default false
+   */
+  accessOrder?: boolean;
+}
+/**
+ * LinkedHashMap<K, V> - Hash map with predictable iteration order.
+ *
+ * This class maintains a doubly-linked list of entries to preserve insertion order
+ * (or access order if accessOrder is true).
+ */
+export declare class LinkedHashMap<K, V> implements MapLike<K, V> {
+  private _buckets;
+  private _size;
+  private readonly _loadFactor;
+  private readonly _eq;
+  private readonly _hash;
+  private readonly _valueEq;
+  private readonly _accessOrder;
+  private _head;
+  private _tail;
+  constructor(options?: LinkedHashMapOptions<K, V>);
+  get size(): number;
+  get isEmpty(): boolean;
+  get eq(): Eq<K>;
+  get keyEq(): Eq<K>;
+  get valueEq(): Eq<V>;
+  get hash(): Hash<K>;
+  has(key: K): boolean;
+  containsKey(key: K): boolean;
+  containsValue(value: V): boolean;
+  get(key: K): V;
+  getOrUndefined(key: K): V | undefined;
+  getOrDefault(key: K, defaultValue: V): V;
+  set(key: K, value: V): V | undefined;
+  setIfAbsent(key: K, value: V): V;
+  replace(key: K, value: V): V | undefined;
+  replaceEntry(key: K, oldValue: V, newValue: V): boolean;
+  delete(key: K): V | undefined;
+  deleteEntry(key: K, value: V): boolean;
+  clear(): void;
+  putAll(other: MapLike<K, V> | Iterable<Entry<K, V>>): void;
+  computeIfAbsent(key: K, mappingFunction: (key: K) => V): V;
+  computeIfPresent(key: K, remappingFunction: (key: K, value: V) => V | undefined): V | undefined;
+  compute(key: K, remappingFunction: (key: K, value: V | undefined) => V | undefined): V | undefined;
+  merge(key: K, value: V, remappingFunction: (oldValue: V, newValue: V) => V | undefined): V | undefined;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<Entry<K, V>>;
+  [Symbol.iterator](): Iterator<Entry<K, V>>;
+  forEach(action: (value: V, key: K, map: this) => void): void;
+  toArray(): Entry<K, V>[];
+  private getNode;
+  private getBucketIndex;
+  private removeFromBucket;
+  private addToEnd;
+  private removeFromList;
+  private moveToEnd;
+  private resize;
+  toString(): string;
+}
+/**
+ * Factory function to make a LinkedHashMap.
+ *
+ * @example
+ * const map = linkedHashMap<string, number>()
+ * map.set('a', 1)
+ * map.set('b', 2)
+ *
+ * @example
+ * // With initial entries
+ * const map = linkedHashMap<string, number>([
+ *   ['a', 1],
+ *   ['b', 2]
+ * ])
+ *
+ * @example
+ * // LRU cache with access order
+ * const lru = linkedHashMap<string, number>({ accessOrder: true })
+ */
+export declare function linkedHashMap<K, V>(optionsOrEntries?: LinkedHashMapOptions<K, V> | Iterable<[K, V]>): LinkedHashMap<K, V>;
+/**
+ * Options for making a TreeMap.
+ */
+export interface TreeMapOptions<K, V> {
+  /**
+   * Comparison function for keys.
+   * @default defaultCompare
+   */
+  compare?: Compare<K>;
+  /**
+   * Equality function for keys.
+   * @default defaultEq
+   */
+  eq?: Eq<K>;
+  /**
+   * Equality function for values.
+   * @default defaultEq
+   */
+  valueEq?: Eq<V>;
+}
+/**
+ * TreeMap<K, V> - Red-black tree based sorted map.
+ *
+ * Maintains keys in sorted order using a self-balancing binary search tree.
+ * This class gives O(log n) operations and navigation methods.
+ */
+export declare class TreeMap<K, V> implements NavigableMap<K, V> {
+  private _root;
+  private _size;
+  private readonly _compare;
+  private readonly _eq;
+  private readonly _valueEq;
+  constructor(options?: TreeMapOptions<K, V>);
+  get size(): number;
+  get isEmpty(): boolean;
+  get comparator(): Compare<K>;
+  get keyEq(): Eq<K>;
+  get valueEq(): Eq<V>;
+  has(key: K): boolean;
+  containsKey(key: K): boolean;
+  containsValue(value: V): boolean;
+  get(key: K): V;
+  getOrUndefined(key: K): V | undefined;
+  getOrDefault(key: K, defaultValue: V): V;
+  set(key: K, value: V): V | undefined;
+  setIfAbsent(key: K, value: V): V;
+  replace(key: K, value: V): V | undefined;
+  replaceEntry(key: K, oldValue: V, newValue: V): boolean;
+  delete(key: K): V | undefined;
+  deleteEntry(key: K, value: V): boolean;
+  clear(): void;
+  putAll(other: NavigableMap<K, V> | Iterable<Entry<K, V>>): void;
+  computeIfAbsent(key: K, mappingFunction: (key: K) => V): V;
+  computeIfPresent(key: K, remappingFunction: (key: K, value: V) => V | undefined): V | undefined;
+  compute(key: K, remappingFunction: (key: K, value: V | undefined) => V | undefined): V | undefined;
+  merge(key: K, value: V, remappingFunction: (oldValue: V, newValue: V) => V | undefined): V | undefined;
+  firstKey(): K;
+  lastKey(): K;
+  headMap(toKey: K): SortedMap<K, V>;
+  tailMap(fromKey: K): SortedMap<K, V>;
+  subMap(fromKey: K, toKey: K): SortedMap<K, V>;
+  floorKey(key: K): K | undefined;
+  ceilingKey(key: K): K | undefined;
+  lowerKey(key: K): K | undefined;
+  higherKey(key: K): K | undefined;
+  floorEntry(key: K): Entry<K, V> | undefined;
+  ceilingEntry(key: K): Entry<K, V> | undefined;
+  lowerEntry(key: K): Entry<K, V> | undefined;
+  higherEntry(key: K): Entry<K, V> | undefined;
+  firstEntry(): Entry<K, V> | undefined;
+  lastEntry(): Entry<K, V> | undefined;
+  pollFirstEntry(): Entry<K, V> | undefined;
+  pollLastEntry(): Entry<K, V> | undefined;
+  descendingMap(): NavigableMap<K, V>;
+  descendingKeys(): IterableIterator<K>;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<Entry<K, V>>;
+  [Symbol.iterator](): Iterator<Entry<K, V>>;
+  forEach(action: (value: V, key: K, map: this) => void): void;
+  toArray(): Entry<K, V>[];
+  private createNode;
+  private getNode;
+  private getFirstNode;
+  private getLastNode;
+  private findValue;
+  private inOrderTraversal;
+  private reverseInOrderTraversal;
+  private rotateLeft;
+  private rotateRight;
+  private fixAfterInsertion;
+  /**
+   * This method deletes a node (the CLRS algorithm, as in java.util.TreeMap). A null leaf counts as black.
+   *
+   * Before (BUGS-2026-07 L10): the deletion of a black leaf skipped the fix-up, so the black
+   * heights drifted and the tree became unbalanced. Also, the fix-up treated a null leaf as
+   * "not black", so it chose the wrong case and rotated at null (a TypeError).
+   */
+  private deleteNode;
+  private fixAfterDeletion;
+  toString(): string;
+}
+/**
+ * Factory function to make a TreeMap.
+ *
+ * @example
+ * const map = treeMap<string, number>()
+ * map.set('c', 3)
+ * map.set('a', 1)
+ * map.set('b', 2)
+ * // Iteration order: a, b, c
+ *
+ * @example
+ * // With initial entries
+ * const map = treeMap<string, number>([
+ *   ['c', 3],
+ *   ['a', 1],
+ *   ['b', 2]
+ * ])
+ *
+ * @example
+ * // Custom comparator for descending order
+ * const map = treeMap<number, string>({ compare: (a, b) => b - a })
+ */
+export declare function treeMap<K, V>(optionsOrEntries?: TreeMapOptions<K, V> | Iterable<[K, V]>): TreeMap<K, V>;
+/**
+ * Options for making a TreeSet.
+ */
+export interface TreeSetOptions<T> {
+  /**
+   * Comparison function for elements.
+   * @default defaultCompare
+   */
+  compare?: Compare<T>;
+  /**
+   * Equality function for elements.
+   * @default defaultEq
+   */
+  eq?: Eq<T>;
+}
+/**
+ * TreeSet<T> - Red-black tree based sorted set.
+ *
+ * Maintains elements in sorted order using a TreeMap as backing structure.
+ * This class gives O(log n) operations and navigation methods.
+ */
+export declare class TreeSet<T> implements NavigableSet<T> {
+  private readonly _map;
+  private readonly _compare;
+  private readonly _eq;
+  constructor(options?: TreeSetOptions<T>);
+  get size(): number;
+  get isEmpty(): boolean;
+  get comparator(): Compare<T>;
+  get eq(): Eq<T>;
+  has(element: T): boolean;
+  contains(element: T): boolean;
+  containsAll(other: Iterable<T>): boolean;
+  add(element: T): boolean;
+  remove(element: T): boolean;
+  clear(): void;
+  addAll(elements: Iterable<T>): boolean;
+  removeAll(elements: Iterable<T>): boolean;
+  retainAll(elements: Iterable<T>): boolean;
+  union(other: Iterable<T>): TreeSet<T>;
+  intersection(other: Iterable<T>): TreeSet<T>;
+  difference(other: Iterable<T>): TreeSet<T>;
+  symmetricDifference(other: Iterable<T>): TreeSet<T>;
+  isSubsetOf(other: Iterable<T>): boolean;
+  isSupersetOf(other: Iterable<T>): boolean;
+  isDisjointFrom(other: Iterable<T>): boolean;
+  first(): T;
+  last(): T;
+  headSet(toElement: T): SortedSet<T>;
+  tailSet(fromElement: T): SortedSet<T>;
+  subSet(fromElement: T, toElement: T): SortedSet<T>;
+  floor(element: T): T | undefined;
+  ceiling(element: T): T | undefined;
+  lower(element: T): T | undefined;
+  higher(element: T): T | undefined;
+  pollFirst(): T | undefined;
+  pollLast(): T | undefined;
+  descendingSet(): NavigableSet<T>;
+  descendingIterator(): IterableIterator<T>;
+  [Symbol.iterator](): Iterator<T>;
+  forEach(action: (element: T, index: number) => void): void;
+  toArray(): T[];
+  toString(): string;
+}
+/**
+ * Factory function to make a TreeSet.
+ *
+ * @example
+ * const set = treeSet<string>()
+ * set.add('c')
+ * set.add('a')
+ * set.add('b')
+ * // Iteration order: a, b, c
+ *
+ * @example
+ * // With initial elements
+ * const set = treeSet(['c', 'a', 'b'])
+ * // Iteration order: a, b, c
+ *
+ * @example
+ * // Custom comparator for descending order
+ * const set = treeSet<number>({ compare: (a, b) => b - a })
+ */
+export declare function treeSet<T>(optionsOrElements?: TreeSetOptions<T> | Iterable<T>): TreeSet<T>;
+/**
+ * Options for making a LinkedList.
+ */
+export interface LinkedListOptions<T> {
+  /**
+   * Equality function for comparing elements.
+   * @default defaultEq (===)
+   */
+  eq?: Eq<T>;
+}
+/**
+ * LinkedList<T> - Doubly-linked list implementation.
+ *
+ * Efficient for:
+ * - Insertion/removal at ends: O(1)
+ * - Insertion/removal at known position: O(1)
+ * - Sequential iteration: O(n)
+ *
+ * Not efficient for:
+ * - Random access by index: O(n)
+ * - Search: O(n)
+ *
+ * This class implements both List and Deque interfaces.
+ */
+export declare class LinkedList<T> implements List<T>, Deque<T> {
+  private _head;
+  private _tail;
+  private _size;
+  private readonly _eq;
+  constructor(options?: LinkedListOptions<T>);
+  get size(): number;
+  get isEmpty(): boolean;
+  get eq(): Eq<T>;
+  addFirst(element: T): void;
+  addLast(element: T): void;
+  removeFirst(): T;
+  removeLast(): T;
+  pollFirst(): T | undefined;
+  pollLast(): T | undefined;
+  peekFirst(): T;
+  peekLast(): T;
+  peekFirstOrUndefined(): T | undefined;
+  peekLastOrUndefined(): T | undefined;
+  offerFirst(element: T): boolean;
+  offerLast(element: T): boolean;
+  push(element: T): void;
+  pop(): T;
+  offer(element: T): boolean;
+  poll(): T;
+  peek(): T;
+  peekOrUndefined(): T | undefined;
+  pollOrUndefined(): T | undefined;
+  enqueue(element: T): boolean;
+  dequeue(): T;
+  get(index: number): T;
+  set(index: number, element: T): T;
+  insert(index: number, element: T): void;
+  insertAll(index: number, other: Iterable<T>): boolean;
+  removeAt(index: number): T;
+  removeRange(fromIndex: number, toIndex: number): void;
+  indexOf(element: T, fromIndex?: number): number;
+  lastIndexOf(element: T, fromIndex?: number): number;
+  first(): T;
+  last(): T;
+  shift(): T;
+  unshift(element: T): void;
+  add(element: T): boolean;
+  addAll(other: Iterable<T>): boolean;
+  contains(element: T): boolean;
+  containsAll(other: Iterable<T>): boolean;
+  remove(element: T): boolean;
+  removeAll(other: Iterable<T>): boolean;
+  retainAll(other: Iterable<T>): boolean;
+  clear(): void;
+  sort(compare?: Compare<T>): void;
+  reverse(): void;
+  subList(fromIndex: number, toIndex: number): List<T>;
+  [Symbol.iterator](): Iterator<T>;
+  forEach(action: (element: T, index: number) => void): void;
+  toArray(): T[];
+  private getNode;
+  private unlinkNode;
+  toString(): string;
+}
+/**
+ * Factory function to make a LinkedList.
+ *
+ * @example
+ * const list = linkedList<number>()
+ * const listFromArray = linkedList([1, 2, 3])
+ */
+export declare function linkedList<T>(optionsOrElements?: LinkedListOptions<T> | Iterable<T>): LinkedList<T>;
+/**
+ * Options for making a HashSet.
+ */
+export interface HashSetOptions<T> {
+  /**
+   * Initial capacity.
+   * @default 16
+   */
+  initialCapacity?: number;
+  /**
+   * Load factor threshold for resizing.
+   * @default 0.75
+   */
+  loadFactor?: number;
+  /**
+   * Equality function for elements.
+   * @default defaultEq (===)
+   */
+  eq?: Eq<T>;
+  /**
+   * Hash function for elements.
+   * @default defaultHash
+   */
+  hash?: Hash<T>;
+}
+/**
+ * HashSet<T> - Hash table implementation of the Set interface.
+ *
+ * A HashMap holds the elements. Its values are a dummy constant.
+ * This class gives constant-time performance for basic operations.
+ *
+ * Not thread-safe. Use synchronized() behavior for concurrent access.
+ */
+export declare class HashSet<T> implements Set$1<T> {
+  private readonly _map;
+  private readonly _eq;
+  constructor(options?: HashSetOptions<T>);
+  get size(): number;
+  get isEmpty(): boolean;
+  get eq(): Eq<T>;
+  add(element: T): boolean;
+  remove(element: T): boolean;
+  contains(element: T): boolean;
+  addAll(other: Iterable<T>): boolean;
+  removeAll(other: Iterable<T>): boolean;
+  retainAll(other: Iterable<T>): boolean;
+  containsAll(other: Iterable<T>): boolean;
+  clear(): void;
+  /**
+   * This method gives a new set that is the union of this set and the other set.
+   * The new set contains all elements from both sets.
+   */
+  union(other: Iterable<T>): HashSet<T>;
+  /**
+   * This method gives a new set that is the intersection of this set and the other set.
+   * The new set contains only elements present in both sets.
+   */
+  intersection(other: Iterable<T>): HashSet<T>;
+  /**
+   * This method gives a new set that is the difference of this set and the other set.
+   * The new set contains elements in this set but not in the other set.
+   */
+  difference(other: Iterable<T>): HashSet<T>;
+  /**
+   * This method gives a new set that is the symmetric difference of this set and the other set.
+   * The new set contains elements in either set but not in both.
+   */
+  symmetricDifference(other: Iterable<T>): HashSet<T>;
+  /**
+   * This method gives true if this set is a subset of the other set.
+   * All elements in this set are also in the other set.
+   */
+  isSubsetOf(other: Iterable<T>): boolean;
+  /**
+   * This method gives true if this set is a superset of the other set.
+   * All elements in the other set are also in this set.
+   */
+  isSupersetOf(other: Iterable<T>): boolean;
+  /**
+   * This method gives true if this set and the other set have no elements in common.
+   */
+  isDisjointFrom(other: Iterable<T>): boolean;
+  [Symbol.iterator](): Iterator<T>;
+  forEach(action: (element: T, index: number) => void): void;
+  toArray(): T[];
+  /**
+   * This method makes a shallow copy of this set.
+   */
+  clone(): HashSet<T>;
+  /**
+   * This method gives statistics about the underlying hash table.
+   */
+  getStats(): ReturnType<HashMap<T, symbol>["getStats"]>;
+  /**
+   * This method gives a string representation for debugging.
+   */
+  toString(): string;
+}
+/**
+ * Factory function to make a HashSet.
+ *
+ * @example
+ * const set = hashSet<number>()
+ * const setFromArray = hashSet([1, 2, 3, 2, 1]) // {1, 2, 3}
+ * const setWithOptions = hashSet<string>({ initialCapacity: 32 })
+ */
+export declare function hashSet<T>(optionsOrElements?: HashSetOptions<T> | Iterable<T>): HashSet<T>;
+/**
+ * Options for making a PriorityQueue.
+ */
+export interface PriorityQueueOptions<T> {
+  /**
+   * Initial capacity of the heap.
+   * @default 11
+   */
+  initialCapacity?: number;
+  /**
+   * Comparator for ordering elements.
+   * Lower values have higher priority (min heap).
+   * @default defaultCompare
+   */
+  compare?: Compare<T>;
+  /**
+   * Equality function for elements.
+   * @default defaultEq
+   */
+  eq?: Eq<T>;
+}
+/**
+ * PriorityQueue<T> - Binary heap implementation of priority queue.
+ *
+ * Elements are always retrieved in priority order (according to comparator).
+ * Not a FIFO queue - order depends on priority, not insertion order.
+ *
+ * The heap is a min heap by default (smallest element has highest priority).
+ * For max heap, use reversed comparator: (a, b) => compare(b, a)
+ *
+ * Not thread-safe. Use synchronized() behavior for concurrent access.
+ */
+declare class PriorityQueue$1<T> implements PriorityQueue<T> {
+  private _heap;
+  private readonly _compare;
+  private readonly _eq;
+  constructor(options?: PriorityQueueOptions<T>);
+  get size(): number;
+  get isEmpty(): boolean;
+  get eq(): Eq<T>;
+  get compare(): Compare<T>;
+  get comparator(): Compare<T>;
+  offer(element: T): boolean;
+  poll(): T;
+  pollOrUndefined(): T | undefined;
+  peek(): T;
+  peekOrUndefined(): T | undefined;
+  enqueue(element: T): boolean;
+  dequeue(): T;
+  add(element: T): boolean;
+  addAll(other: Iterable<T>): boolean;
+  contains(element: T): boolean;
+  containsAll(other: Iterable<T>): boolean;
+  remove(element: T): boolean;
+  removeAll(other: Iterable<T>): boolean;
+  retainAll(other: Iterable<T>): boolean;
+  clear(): void;
+  /**
+   * Iterator gives elements in arbitrary order (not priority order).
+   * To get elements in priority order, repeatedly call poll().
+   */
+  [Symbol.iterator](): Iterator<T>;
+  forEach(action: (element: T, index: number) => void): void;
+  /**
+   * This method gives elements in arbitrary heap order (not sorted).
+   */
+  toArray(): T[];
+  /**
+   * This method gives elements in priority order (sorted).
+   * This is a destructive operation that drains the queue.
+   */
+  toSortedArray(): T[];
+  /**
+   * This method bubbles an element up the heap to maintain heap property.
+   */
+  private bubbleUp;
+  /**
+   * This method bubbles an element down the heap to maintain heap property.
+   *
+   * The element moves down through a hole: a smaller child moves up into the hole, and the
+   * element goes into the last hole. The children are compared with the element.
+   * Before, they were compared with `_heap[index]`. After the first step, that value is a copy of
+   * the child that moved up. Thus a poll could leave a larger element above a smaller one.
+   */
+  private bubbleDown;
+  /**
+   * This method rebuilds the heap from an arbitrary array.
+   * This method uses Floyd's algorithm (O(n) time).
+   */
+  private heapify;
+  /**
+   * This method makes a shallow copy of this priority queue.
+   */
+  clone(): PriorityQueue$1<T>;
+  /**
+   * This method validates the heap property (for debugging).
+   * This method gives true if the heap is valid.
+   */
+  validate(): boolean;
+  /**
+   * This method gives a string representation for debugging.
+   */
+  toString(): string;
+}
+/**
+ * Factory function to make a PriorityQueue.
+ *
+ * @example
+ * // Min heap (default)
+ * const minHeap = priorityQueue<number>()
+ *
+ * // Max heap
+ * const maxHeap = priorityQueue<number>((a, b) => b - a)
+ *
+ * // From array
+ * const pq = priorityQueue([5, 2, 8, 1, 9])
+ *
+ * // With custom comparator
+ * const pq = priorityQueue<Task>((a, b) => a.priority - b.priority)
+ */
+export declare function priorityQueue<T>(optionsOrElementsOrComparator?: PriorityQueueOptions<T> | Iterable<T> | Compare<T>): PriorityQueue$1<T>;
+/**
+ * SummaryTree: a persistent sequence of leaves with a summary of each part.
+ *
+ * The tree is a balanced binary tree (AVL) with one leaf in each node. Each node keeps the summary of its subtree.
+ * A summary is a value of a monoid: the caller gives the monoid as data, with `empty` and `combine`. The order of the
+ * leaves is kept, so `combine` must be associative, but it can be non-commutative.
+ *
+ * Each operation gives a new tree and keeps the old tree. The two trees share the nodes that did not change.
+ * Concatenation, a split at an index or at a summary search, an edit and a lookup are O(log n).
+ *
+ * The algorithms are the "join" algorithms of Blelloch, Ferizovic and Sun, "Just Join for Parallel Ordered Sets"
+ * (SPAA 2016).
+ *
+ * @example
+ * // The number of leaves and the total length of the strings
+ * const spec = {
+ *   monoid: { empty: { count: 0, length: 0 }, combine: (a, b) => ({ count: a.count + b.count, length: a.length + b.length }) },
+ *   measure: (leaf: string) => ({ count: 1, length: leaf.length }),
+ * };
+ * const tree = summaryTree(spec, ["ab", "cde", "f"]);
+ * tree.summary; // { count: 3, length: 6 }
+ * const [left, right] = tree.split((prefix) => prefix.length > 2); // left: ["ab"], right: ["cde", "f"]
+ */
+/** A monoid as data: the identity value `empty` and an associative operation `combine`. */
+interface SummaryMonoid<Summary> {
+  /** The summary of a sequence with no leaf. `combine(empty, s)` and `combine(s, empty)` are equal to `s`. */
+  readonly empty: Summary;
+  /** This function gives the summary of a sequence from the summaries of its two parts, left first. */
+  readonly combine: (left: Summary, right: Summary) => Summary;
+}
+/** The data that a tree needs: the monoid of the summaries and the summary of one leaf. */
+interface SummarySpec<Leaf, Summary> {
+  readonly monoid: SummaryMonoid<Summary>;
+  /** This function gives the summary of one leaf. */
+  readonly measure: (leaf: Leaf) => Summary;
+  /**
+   * This optional function joins two neighbor leaves at a seam into one leaf, or gives `undefined` to keep both. A seam
+   * is the place where `concat`, `append`, `prepend`, `splice`, `insert` or `remove` puts two leaves next to each other.
+   * The tree calls it once at each seam, and not between the leaves that one call inserts. `set` does not call it.
+   */
+  readonly merge?: (left: Leaf, right: Leaf) => Leaf | undefined;
+}
+/** The result of a summary search: the first leaf whose prefix summary satisfies the predicate. */
+interface SummarySearch<Leaf, Summary> {
+  /** The index of the leaf. */
+  readonly index: number;
+  readonly leaf: Leaf;
+  /** The summary of the leaves before the leaf. */
+  readonly before: Summary;
+  /** The summary of the leaves before the leaf, and of the leaf. */
+  readonly through: Summary;
+}
+/** The result of `locate`: the leaf that holds a position of an additive key, and the position in that leaf. */
+interface SummaryLocation<Leaf> {
+  /** The index of the leaf. */
+  readonly index: number;
+  readonly leaf: Leaf;
+  /** The position in the leaf: the target minus the key of the leaves before the leaf. */
+  readonly offset: number;
+}
+/**
+ * A persistent sequence of leaves with a summary of each part. Make one with `summaryTree`. Each method that changes
+ * the sequence gives a new tree.
+ */
+export declare class SummaryTree<Leaf, Summary> implements Iterable<Leaf> {
+  private readonly builder;
+  private readonly root;
+  private constructor();
+  /** This function makes a tree of a spec from leaves, as `summaryTree` does. */
+  static of<Leaf, Summary>(spec: SummarySpec<Leaf, Summary>, leaves?: Iterable<Leaf>): SummaryTree<Leaf, Summary>;
+  private wrap;
+  private treeOf;
+  /** The spec of the tree: its monoid and its measure. */
+  get spec(): SummarySpec<Leaf, Summary>;
+  /** The number of leaves. */
+  get size(): number;
+  get isEmpty(): boolean;
+  /** The summary of all the leaves, in their order. An empty tree has the summary `monoid.empty`. */
+  get summary(): Summary;
+  /** The height of the tree: 0 for an empty tree. The height is at most 1.45 log2(size + 2). */
+  get height(): number;
+  /**
+   * This function gives the leaf at an index, or `undefined` when the index is not in the tree. A negative index counts
+   * from the end, as `Array.prototype.at` does.
+   */
+  at(index: number): Leaf | undefined;
+  /** This function gives the summary of the leaves from `start` to `end`, with `end` not included. */
+  summaryOf(start?: number, end?: number): Summary;
+  /** This function gives the tree of the leaves of this tree, then the leaves of `other`. The two trees must have the same spec. */
+  concat(other: SummaryTree<Leaf, Summary> | Iterable<Leaf>): SummaryTree<Leaf, Summary>;
+  /** This function splits the tree into its first `index` leaves and the other leaves. */
+  splitAt(index: number): [SummaryTree<Leaf, Summary>, SummaryTree<Leaf, Summary>];
+  /**
+   * This function splits the tree before the first leaf whose prefix summary satisfies the predicate. The prefix of a
+   * leaf includes the leaf. The predicate must be monotone: after it is true for a prefix, it is true for each longer
+   * prefix. When no prefix satisfies it, the right tree is empty.
+   */
+  split(predicate: (prefix: Summary) => boolean): [SummaryTree<Leaf, Summary>, SummaryTree<Leaf, Summary>];
+  /**
+   * This function finds the first leaf whose prefix summary satisfies a monotone predicate, as `split` does. It changes
+   * nothing. It gives `undefined` when no prefix satisfies the predicate.
+   */
+  search(predicate: (prefix: Summary) => boolean): SummarySearch<Leaf, Summary> | undefined;
+  /**
+   * This function finds the leaf that holds a position of an additive key, and it calls no `combine`. The key must be
+   * additive and not negative: `key(combine(a, b))` is `key(a) + key(b)`. The function descends by the key of each left
+   * subtree and of each leaf, and subtracts it from the target. It gives the first leaf whose prefix key is more than
+   * the target, or `undefined` when the target is not in `[0, key(summary))`.
+   *
+   * @example
+   * // The leaf and the offset in it of the code unit at position 1000 of a rope
+   * const at = rope.locate((s) => s.length, 1000);
+   */
+  locate(key: (summary: Summary) => number, target: number): SummaryLocation<Leaf> | undefined;
+  /** This function gives the tree of the leaves from `start` to `end`, with `end` not included. A negative index counts from the end. */
+  slice(start?: number, end?: number): SummaryTree<Leaf, Summary>;
+  /**
+   * This function removes `deleteCount` leaves at `start` and puts the leaves of `inserted` there, as
+   * `Array.prototype.splice` does. It gives the new tree, not the removed leaves.
+   */
+  splice(start: number, deleteCount?: number, inserted?: SummaryTree<Leaf, Summary> | Iterable<Leaf>): SummaryTree<Leaf, Summary>;
+  /** This function puts the leaves of `inserted` before the leaf at `index`. */
+  insert(index: number, inserted: SummaryTree<Leaf, Summary> | Iterable<Leaf>): SummaryTree<Leaf, Summary>;
+  /** This function removes the leaves from `start` to `end`, with `end` not included. */
+  remove(start: number, end?: number): SummaryTree<Leaf, Summary>;
+  /**
+   * This function replaces the leaf at an index. A negative index counts from the end, as `Array.prototype.with` does.
+   * An index that is not in the tree changes nothing. It copies only the path to the leaf, and it does not call
+   * `spec.merge`.
+   */
+  set(index: number, leaf: Leaf): SummaryTree<Leaf, Summary>;
+  /** This function adds leaves after the last leaf. */
+  append(...leaves: Leaf[]): SummaryTree<Leaf, Summary>;
+  /** This function adds leaves before the first leaf. */
+  prepend(...leaves: Leaf[]): SummaryTree<Leaf, Summary>;
+  /** This function gives the leaves in their order. */
+  [Symbol.iterator](): Iterator<Leaf>;
+  /** This function gives the leaves in an array. */
+  toArray(): Leaf[];
+}
+/**
+ * This function makes a persistent tree of leaves with a summary of each part. Use the same `spec` object for each
+ * tree that `concat` or `splice` joins.
+ */
+export declare function summaryTree<Leaf, Summary>(spec: SummarySpec<Leaf, Summary>, leaves?: Iterable<Leaf>): SummaryTree<Leaf, Summary>;
+/**
+ * Options for bounded behavior.
+ */
+interface BoundedOptions<T> {
+  /**
+   * Maximum number of elements the collection can hold.
+   */
+  capacity: number;
+  /**
+   * Policy for handling overflow when collection is full.
+   * @default 'throw'
+   */
+  policy?: OverflowPolicy;
+  /**
+   * Optional callback invoked when overflow occurs.
+   * The behavior calls this function before it applies the policy.
+   */
+  onOverflow?: OverflowHandler<T>;
+}
+/**
+ * Marker interface for bounded collections.
+ */
+interface BoundedCollection$1 {
+  readonly capacity: number;
+  readonly isFull: boolean;
+  readonly remainingCapacity: number;
+}
+/**
+ * This function makes a bounded List middleware.
+ *
+ * Intercepts add operations to enforce capacity limits.
+ * This function supports multiple overflow policies.
+ */
+export declare function boundedList<T>(options: BoundedOptions<T>): Middleware<List<T>, List<T> & BoundedCollection$1>;
+/**
+ * This function makes a bounded Queue middleware.
+ */
+export declare function boundedQueue<T>(options: BoundedOptions<T>): Middleware<Queue<T>, Queue<T> & BoundedCollection$1>;
+/**
+ * This function makes a bounded Deque middleware.
+ */
+export declare function boundedDeque<T>(options: BoundedOptions<T>): Middleware<Deque<T>, Deque<T> & BoundedCollection$1>;
+/**
+ * This function makes a bounded Map middleware.
+ */
+export declare function boundedMap<K, V>(options: Omit<BoundedOptions<V>, "onOverflow"> & {
+  onOverflow?: (context: Omit<OverflowContext<V>, "newElement"> & {
+    key: K;
+    value: V;
+  }) => void;
+}): Middleware<MapLike<K, V>, MapLike<K, V> & BoundedCollection$1>;
+/**
+ * Generic bounded collection middleware.
+ * Works with any collection type.
+ */
+export declare function bounded<C extends Collection<any>>(options: BoundedOptions<any>): Middleware<C, C & BoundedCollection$1>;
+/**
+ * Options for readonly behavior.
+ */
+export interface ReadonlyOptions {
+  /**
+   * Custom error message to throw on mutation tries.
+   * @default 'Cannot modify readonly collection'
+   */
+  errorMessage?: string;
+}
+/**
+ * This function makes a readonly List middleware.
+ *
+ * All mutation methods will throw an error.
+ * Read operations work normally.
+ *
+ * @example
+ * const readonlyNumbers = compose(
+ *   readonlyList()
+ * )(arrayList([1, 2, 3]))
+ */
+export declare function readonlyList<T>(options?: ReadonlyOptions): Middleware<ReadonlyList<T>>;
+/**
+ * This function makes a readonly Queue middleware.
+ */
+export declare function readonlyQueue<T>(options?: ReadonlyOptions): Middleware<ReadonlyQueue<T>>;
+/**
+ * This function makes a readonly Map middleware.
+ */
+export declare function readonlyMap<K, V>(options?: ReadonlyOptions): Middleware<ReadonlyMapLike<K, V>>;
+/**
+ * This function makes a readonly Collection middleware.
+ *
+ * Generic version that works with any collection type.
+ */
+export declare function readonlyCollection<T>(options?: ReadonlyOptions): Middleware<ReadonlyCollection<T>>;
+/**
+ * Generic readonly middleware.
+ * Alias for readonlyCollection.
+ */
+export declare function readonly<C extends object>(options?: ReadonlyOptions): Middleware<C>;
+/**
+ * Alias for Java compatibility: unmodifiableList
+ */
+export declare const unmodifiableList: typeof readonlyList;
+/**
+ * Alias for Java compatibility: unmodifiableMap
+ */
+export declare const unmodifiableMap: typeof readonlyMap;
+/**
+ * Alias for Java compatibility: unmodifiableCollection
+ */
+export declare const unmodifiableCollection: typeof readonlyCollection;
+/**
+ * Safe operations for List.
+ */
+export interface SafeListOperations<T> {
+  /**
+   * Get element at index, giving Option.
+   */
+  get(index: number): Option<T>;
+  /**
+   * Set element at index, giving Result with old value or error.
+   */
+  set(index: number, element: T): Result<T, string>;
+  /**
+   * Remove element at index, giving Result with removed value or error.
+   */
+  removeAt(index: number): Result<T, string>;
+  /**
+   * Get first element as Option.
+   */
+  first(): Option<T>;
+  /**
+   * Get last element as Option.
+   */
+  last(): Option<T>;
+  /**
+   * Pop element, giving Option.
+   */
+  pop(): Option<T>;
+  /**
+   * Shift element, giving Option.
+   */
+  shift(): Option<T>;
+}
+/**
+ * Safe operations for Queue.
+ */
+export interface SafeQueueOperations<T> {
+  /**
+   * Peek at head element as Option.
+   */
+  peek(): Option<T>;
+  /**
+   * Poll element as Option.
+   */
+  poll(): Option<T>;
+  /**
+   * Dequeue element as Option.
+   */
+  dequeue(): Option<T>;
+}
+/**
+ * Safe operations for Deque.
+ */
+export interface SafeDequeOperations<T> extends SafeQueueOperations<T> {
+  /**
+   * Peek at first element as Option.
+   */
+  peekFirst(): Option<T>;
+  /**
+   * Peek at last element as Option.
+   */
+  peekLast(): Option<T>;
+  /**
+   * Poll first element as Option.
+   */
+  pollFirst(): Option<T>;
+  /**
+   * Poll last element as Option.
+   */
+  pollLast(): Option<T>;
+  /**
+   * Pop element as Option.
+   */
+  pop(): Option<T>;
+}
+/**
+ * Safe operations for Map.
+ */
+export interface SafeMapOperations<K, V> {
+  /**
+   * Get value for key as Option.
+   */
+  get(key: K): Option<V>;
+  /**
+   * Set value for key, giving Result with old value or success.
+   */
+  set(key: K, value: V): Result<V | undefined, string>;
+  /**
+   * Delete key, giving Result with deleted value or error.
+   */
+  delete(key: K): Result<V | undefined, string>;
+}
+/**
+ * This function makes a safe List middleware.
+ *
+ * This function exposes a `safe` property with Option/Result-based operations.
+ */
+export declare function safeList<T>(): Middleware<List<T>, List<T> & {
+  safe: SafeListOperations<T>;
+}>;
+/**
+ * This function makes a safe Queue middleware.
+ */
+export declare function safeQueue<T>(): Middleware<Queue<T>, Queue<T> & {
+  safe: SafeQueueOperations<T>;
+}>;
+/**
+ * This function makes a safe Deque middleware.
+ */
+export declare function safeDeque<T>(): Middleware<Deque<T>, Deque<T> & {
+  safe: SafeDequeOperations<T>;
+}>;
+/**
+ * This function makes a safe Map middleware.
+ */
+export declare function safeMap<K, V>(): Middleware<MapLike<K, V>, MapLike<K, V> & {
+  safe: SafeMapOperations<K, V>;
+}>;
+/**
+ * Generic safe middleware that works with any collection.
+ */
+export declare function safe<C extends object>(): Middleware<C>;
+/**
+ * Events emitted by List collections.
+ */
+export interface ListEvents<T> {
+  /** Element was added */
+  add: {
+    value: T;
+    index?: number;
+  };
+  /** Element was removed */
+  remove: {
+    value: T;
+    index?: number;
+  };
+  /** Element was replaced */
+  set: {
+    oldValue: T;
+    newValue: T;
+    index: number;
+  };
+  /** Collection was cleared */
+  clear: {};
+  /** Collection was sorted */
+  sort: {};
+  /** Collection was reversed */
+  reverse: {};
+}
+/**
+ * Events emitted by Queue collections.
+ */
+export interface QueueEvents<T> {
+  /** Element was added to queue */
+  enqueue: {
+    value: T;
+  };
+  /** Element was removed from queue */
+  dequeue: {
+    value: T;
+  };
+  /** Collection was cleared */
+  clear: {};
+}
+/**
+ * Events emitted by Deque collections.
+ */
+export interface DequeEvents<T> {
+  /** Element was added to front */
+  addFirst: {
+    value: T;
+  };
+  /** Element was added to back */
+  addLast: {
+    value: T;
+  };
+  /** Element was removed from front */
+  removeFirst: {
+    value: T;
+  };
+  /** Element was removed from back */
+  removeLast: {
+    value: T;
+  };
+  /** Collection was cleared */
+  clear: {};
+}
+/**
+ * Events emitted by Map collections.
+ */
+export interface MapEvents<K, V> {
+  /** Key-value pair was set */
+  set: {
+    key: K;
+    value: V;
+    oldValue?: V;
+  };
+  /** Key was deleted */
+  delete: {
+    key: K;
+    value: V;
+  };
+  /** Collection was cleared */
+  clear: {};
+}
+/**
+ * Generic collection events.
+ */
+export interface CollectionEvents<T> {
+  /** Element was added */
+  add: {
+    value: T;
+  };
+  /** Element was removed */
+  remove: {
+    value: T;
+  };
+  /** Collection was cleared */
+  clear: {};
+}
+/**
+ * This function makes an evented List middleware.
+ *
+ * This function emits events for add, remove, set, clear, sort, and reverse operations.
+ */
+export declare function eventedList<T>(): Middleware<List<T>, List<T> & {
+  on<E extends keyof ListEvents<T>>(event: E, listener: (payload: ListEvents<T>[E]) => void): Unsubscribe;
+}>;
+/**
+ * This function makes an evented Queue middleware.
+ */
+export declare function eventedQueue<T>(): Middleware<Queue<T>, Queue<T> & {
+  on<E extends keyof QueueEvents<T>>(event: E, listener: (payload: QueueEvents<T>[E]) => void): Unsubscribe;
+}>;
+/**
+ * This function makes an evented Deque middleware.
+ */
+export declare function eventedDeque<T>(): Middleware<Deque<T>, Deque<T> & {
+  on<E extends keyof DequeEvents<T>>(event: E, listener: (payload: DequeEvents<T>[E]) => void): Unsubscribe;
+}>;
+/**
+ * This function makes an evented Map middleware.
+ */
+export declare function eventedMap<K, V>(): Middleware<MapLike<K, V>, MapLike<K, V> & {
+  on<E extends keyof MapEvents<K, V>>(event: E, listener: (payload: MapEvents<K, V>[E]) => void): Unsubscribe;
+}>;
+/**
+ * Generic evented collection middleware.
+ */
+export declare function evented<T>(): Middleware<Collection<T>, Collection<T> & {
+  on<E extends keyof CollectionEvents<T>>(event: E, listener: (payload: CollectionEvents<T>[E]) => void): Unsubscribe;
+}>;
+/**
+ * This function makes a synchronized middleware that locks all method calls.
+ *
+ * Every method call on the collection is wrapped with a mutex,
+ * making sure that atomic execution even in concurrent async scenarios.
+ *
+ * @example
+ * const syncList = compose(
+ *   synchronized()
+ * )(arrayList<number>())
+ *
+ * // These additions are guaranteed to execute in order
+ * await Promise.all([
+ *   syncList.add(1),
+ *   syncList.add(2),
+ *   syncList.add(3)
+ * ])
+ */
+export declare function synchronized<C extends object>(): Middleware<C>;
+/**
+ * Alias for Java compatibility: synchronizedList
+ */
+export declare const synchronizedList: typeof synchronized;
+/**
+ * Alias for Java compatibility: synchronizedMap
+ */
+export declare const synchronizedMap: typeof synchronized;
+/**
+ * Alias for Java compatibility: synchronizedCollection
+ */
+export declare const synchronizedCollection: typeof synchronized;
+/**
+ * Alias for Java compatibility: synchronizedSet
+ */
+export declare const synchronizedSet: typeof synchronized;
+/**
+ * Advanced synchronized middleware with reentrant locking.
+ *
+ * With this function, the same "thread" (async context) can acquire the lock multiple times.
+ * Useful for methods that call other synchronized methods internally.
+ *
+ * Note: JavaScript has no true thread IDs. This function uses async context
+ * tracking if available. If not, the behavior is non-reentrant.
+ */
+export declare function reentrantSynchronized<C extends object>(): Middleware<C>;
+/**
+ * Read-write lock implementation for collections.
+ *
+ * With this function, multiple concurrent readers can read, but a writer is exclusive.
+ * More efficient than full synchronization for read-heavy workloads.
+ *
+ * @example
+ * const list = compose(
+ *   readWriteLock()
+ * )(arrayList<number>())
+ *
+ * // Multiple reads can happen concurrently
+ * await Promise.all([
+ *   list.get(0),
+ *   list.get(1),
+ *   list.get(2)
+ * ])
+ */
+export declare function readWriteLock<C extends object>(): Middleware<C>;
+/**
+ * Options for LRU behavior.
+ */
+export interface LRUOptions {
+  /**
+   * Maximum capacity. When exceeded, least recently used items are evicted.
+   */
+  capacity: number;
+  /**
+   * Optional callback invoked when an item is evicted.
+   */
+  onEvict?: (info: {
+    key: any;
+    value: any;
+    timestamp: number;
+  }) => void;
+}
+/**
+ * This function makes an LRU Map middleware.
+ *
+ * This function maintains a doubly-linked list to track access order.
+ * Most recently accessed items are at the head.
+ * When capacity is exceeded, items at the tail are evicted.
+ */
+export declare function lruMap<K, V>(options: LRUOptions): Middleware<MapLike<K, V>, MapLike<K, V> & {
+  readonly isFull: boolean;
+}>;
+/**
+ * This class makes an LRU cache with a simpler API.
+ * This is a standalone LRU cache implementation.
+ *
+ * @example
+ * const cache = lruCache<string, Data>(100)
+ * cache.set('key', value)
+ * cache.get('key') // Moves to front
+ */
+export declare class LRUCache<K, V> {
+  private readonly capacity;
+  private readonly onEvict;
+  private map;
+  private head;
+  private tail;
+  constructor(capacity: number, onEvict?: ((key: K, value: V) => void) | undefined);
+  get size(): number;
+  get isFull(): boolean;
+  get(key: K): V | undefined;
+  set(key: K, value: V): void;
+  has(key: K): boolean;
+  delete(key: K): boolean;
+  clear(): void;
+  private moveToHead;
+  private removeNode;
+  private evictLRU;
+  /**
+   * This method gives keys in LRU order (most recent first).
+   */
+  keys(): IterableIterator<K>;
+  /**
+   * This method gives entries in LRU order (most recent first).
+   */
+  entries(): IterableIterator<[K, V]>;
+}
+/**
+ * Factory function to make an LRU cache.
+ */
+export declare function lruCache<K, V>(capacity: number, onEvict?: (key: K, value: V) => void): LRUCache<K, V>;
+/**
+ * Options for TTL behavior.
+ */
+export interface TTLOptions {
+  /**
+   * Time-to-live in milliseconds.
+   * Elements expire after this duration.
+   */
+  ttl: number;
+  /**
+   * Interval for checking expired elements (in milliseconds).
+   * @default 1000 (check every second)
+   */
+  checkInterval?: number;
+  /**
+   * Optional callback invoked when an element expires.
+   */
+  onExpire?: (info: {
+    key: any;
+    value: any;
+    createdAt: number;
+    expiredAt: number;
+  }) => void;
+}
+/**
+ * This function makes a TTL Map middleware.
+ *
+ * Automatically removes entries after TTL expires.
+ * This function uses a background interval to check for expired entries.
+ */
+export declare function ttlMap<K, V>(options: TTLOptions): Middleware<MapLike<K, V>, MapLike<K, V> & {
+  readonly dispose: () => void;
+}>;
+/**
+ * This function makes a TTL Collection middleware.
+ *
+ * Note: This is less precise than TTL map because collections don't have keys.
+ * Elements are tracked by reference, which can fail for primitive types.
+ */
+export declare function ttlCollection<T>(options: Omit<TTLOptions, "onExpire"> & {
+  onExpire?: (info: {
+    element: T;
+    createdAt: number;
+    expiredAt: number;
+  }) => void;
+}): Middleware<Collection<T>, Collection<T> & {
+  readonly dispose: () => void;
+}>;
+/**
+ * Standalone TTL cache with Map-like API.
+ *
+ * @example
+ * const cache = new TTLCache<string, number>(60000) // 60 second TTL
+ * cache.set('key', 42)
+ * setTimeout(() => {
+ *   cache.get('key') // undefined (expired)
+ * }, 61000)
+ */
+export declare class TTLCache<K, V> {
+  private readonly ttl;
+  private readonly checkInterval;
+  private readonly onExpire;
+  private map;
+  private intervalId;
+  constructor(ttl: number, checkInterval?: number, onExpire?: ((key: K, value: V) => void) | undefined);
+  get size(): number;
+  get(key: K): V | undefined;
+  set(key: K, value: V, customTTL?: number): void;
+  has(key: K): boolean;
+  delete(key: K): boolean;
+  clear(): void;
+  /**
+   * Manually trigger cleanup of expired entries.
+   */
+  cleanup(): void;
+  /**
+   * Get remaining TTL for a key in milliseconds.
+   * This method gives undefined if key doesn't exist or is expired.
+   */
+  getTTL(key: K): number | undefined;
+  /**
+   * Update TTL for an existing key.
+   */
+  touch(key: K, customTTL?: number): boolean;
+  private startExpirationCheck;
+  /**
+   * Stop the background expiration checker and clean up.
+   */
+  dispose(): void;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<[K, V]>;
+}
+/**
+ * Factory function to make a TTL cache.
+ */
+export declare function ttlCache<K, V>(ttl: number, options?: {
+  checkInterval?: number;
+  onExpire?: (key: K, value: V) => void;
+}): TTLCache<K, V>;
+/**
+ * Options for making an AsyncQueue.
+ */
+export interface AsyncQueueOptions {
+  /**
+   * Maximum capacity. Infinity for unbounded queue.
+   * @default Infinity
+   */
+  capacity?: number;
+  /**
+   * Timeout for put/take operations in milliseconds.
+   * @default undefined (no timeout)
+   */
+  timeout?: number;
+}
+/**
+ * AsyncQueue<T> - Thread-safe async queue with backpressure.
+ *
+ * Features:
+ * - Blocking put() when full (backpressure)
+ * - Blocking take() when empty
+ * - AsyncIterable support
+ * - Graceful closing
+ * - Timeouts
+ *
+ * Perfect for:
+ * - Producer-consumer patterns
+ * - Rate limiting
+ * - Task queues
+ * - Stream processing
+ */
+export declare class AsyncQueue<T> implements AsyncQueue$1<T> {
+  private buffer;
+  private putters;
+  private takers;
+  /** The calls of `peek` that wait: they see the next element, but they do not take it. */
+  private peekers;
+  private _isClosed;
+  private readonly capacity;
+  private readonly defaultTimeout?;
+  constructor(options?: AsyncQueueOptions);
+  get size(): number;
+  get isEmpty(): boolean;
+  get isFull(): boolean;
+  get isClosed(): boolean;
+  get remainingCapacity(): number;
+  /**
+   * This method adds an element to the queue.
+   * If the queue is full, waits until space is available. With a capacity of 0, it waits until
+   * a taker takes the element (a rendezvous).
+   *
+   * @throws Error if queue is closed
+   * @throws Error if timeout expires
+   */
+  put(element: T, timeout?: number): Promise<void>;
+  /**
+   * Removes and gives an element from the queue.
+   * If the queue is empty, waits until an element is available.
+   *
+   * @throws Error if queue is closed and empty
+   * @throws Error if timeout expires
+   */
+  take(timeout?: number): Promise<T>;
+  /**
+   * This method waits for the next element, as `take` does, but it gives the element to
+   * `onElement` and the closure of the queue to `onClosed`. These calls are synchronous: they
+   * occur in the call that adds the element or closes the queue. The method has no timeout.
+   *
+   * The function that it gives withdraws the wait. A withdrawn wait gets no element, so no
+   * element goes to a taker that left. `select` races its cases with this method.
+   *
+   * @returns A function that withdraws the wait. It gives true when the wait had no element yet.
+   */
+  waitTake(onElement: (element: T) => void, onClosed: (error: Error) => void): () => boolean;
+  /**
+   * This method tries to add an element without waiting.
+   * This method gives false if queue is full (with a capacity of 0: if no taker waits).
+   */
+  tryPut(element: T): boolean;
+  /**
+   * This method tries to remove an element without waiting.
+   * This method gives undefined if queue is empty.
+   */
+  tryTake(): T | undefined;
+  /** This method gives the element to a waiting taker, or puts it in the buffer when there is space. */
+  private tryPutNow;
+  /** Each waiting peek gets the element, which stays where it is. */
+  private wakePeekers;
+  /**
+   * This method takes the next element: from the buffer (then a waiting putter moves its element into the
+   * buffer), or directly from a waiting putter (a capacity of 0). (Before, the direct path
+   * released the putter but did not give its element to the taker, so the taker waited forever:
+   * BUGS-2026-07 C11.)
+   */
+  private takeNow;
+  /**
+   * This method gives the next element without removing it.
+   * Waits if queue is empty.
+   */
+  peek(): Promise<T>;
+  /**
+   * This method gives the next element without waiting.
+   * This method gives undefined if queue is empty.
+   */
+  tryPeek(): T | undefined;
+  /**
+   * This method closes the queue. No more elements can be added.
+   * Existing elements can still be consumed.
+   */
+  close(): void;
+  /**
+   * This method drains all elements into an array.
+   * This method gives immediately with current elements.
+   */
+  drain(): T[];
+  /**
+   * Async iterator that yields elements as they become available.
+   * Stops when queue is closed and empty.
+   */
+  [Symbol.asyncIterator](): AsyncIterator<T>;
+  /** When the buffer has space, the first waiting putter moves its element into it. */
+  private admitPutter;
+  private clearTimeout;
+  /**
+   * This method gives statistics about the queue.
+   */
+  getStats(): {
+    size: number;
+    capacity: number;
+    isEmpty: boolean;
+    isFull: boolean;
+    isClosed: boolean;
+    waitingPutters: number;
+    waitingTakers: number;
+    remainingCapacity: number;
+  };
+  toString(): string;
+}
+/**
+ * Factory function to make an AsyncQueue.
+ *
+ * @example
+ * const queue = asyncQueue<number>({ capacity: 100 })
+ * await queue.put(42)
+ * const value = await queue.take()
+ */
+export declare function asyncQueue<T>(options?: AsyncQueueOptions): AsyncQueue<T>;
+/**
+ * Channel<T> - Bidirectional communication channel.
+ *
+ * The channels of Go are the model. This class gives send/receive operations
+ * that can block until the other side is ready.
+ */
+export declare class Channel<T> {
+  private queue;
+  private _isClosed;
+  constructor(bufferSize?: number);
+  /**
+   * This method sends a value through the channel.
+   * Blocks if channel buffer is full.
+   *
+   * @throws Error if channel is closed
+   */
+  send(value: T): Promise<void>;
+  /**
+   * This method receives a value from the channel.
+   * Blocks if no value is available.
+   *
+   * @throws Error if channel is closed and empty
+   */
+  receive(): Promise<T>;
+  /**
+   * This method waits for one value, as `receive` does, and gives it to `onValue`. When the
+   * channel is closed and empty, it calls `onClosed`. These calls are synchronous: they occur in
+   * the call that sends the value or closes the channel.
+   *
+   * The function that it gives withdraws the wait, so no later value goes to it.
+   *
+   * @returns A function that withdraws the wait. It gives true when the wait had no value yet.
+   */
+  waitReceive(onValue: (value: T) => void, onClosed: (error: Error) => void): () => boolean;
+  /**
+   * This method tries to send without blocking.
+   * This method gives false if channel is full.
+   */
+  trySend(value: T): boolean;
+  /**
+   * This method tries to receive without blocking.
+   * This method gives undefined if no value is available.
+   */
+  tryReceive(): T | undefined;
+  /**
+   * This method closes the channel. No more values can be sent.
+   * Receivers can still drain remaining values.
+   */
+  close(): void;
+  get isClosed(): boolean;
+  get size(): number;
+  /**
+   * This method makes a select case for this channel.
+   * The select() function uses this value for multiplexing.
+   */
+  case<R>(handler: (value: T) => R): SelectCase<R>;
+  /**
+   * Async iteration over channel values.
+   * Stops when channel is closed and empty.
+   */
+  [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+/**
+ * SelectCase represents a case in a select statement.
+ */
+export interface SelectCase<R> {
+  channel: Channel<any>;
+  handler: (value: any) => R;
+  tryReceive: () => any;
+  receive: () => Promise<any>;
+  /**
+   * A wait for one value that `select` can withdraw: `Channel.waitReceive`. A case without it
+   * uses the `waitReceive` method of its channel.
+   */
+  wait?: (onValue: (value: any) => void, onClosed: (error: Error) => void) => () => boolean;
+}
+/**
+ * Selects from multiple channels (like Go's select statement).
+ *
+ * This function waits for the first channel to have a value available,
+ * then calls its handler and gives the result.
+ *
+ * The first case with a value at once wins. The cases that lose keep no receive: a value that
+ * comes later stays in its channel for the next receiver. When the channel of a case is closed
+ * and empty, the given promise rejects.
+ *
+ * @example
+ * const result = await select(
+ *   ch1.case((v) => `ch1: ${v}`),
+ *   ch2.case((v) => `ch2: ${v}`),
+ *   timeout(1000).case(() => 'timeout')
+ * )
+ */
+export declare function select<R>(...cases: SelectCase<R>[]): Promise<R>;
+/**
+ * This function makes a timeout channel that sends after the specified duration.
+ *
+ * @example
+ * const result = await select(
+ *   dataChannel.case((v) => v),
+ *   timeout(5000).case(() => 'timeout!')
+ * )
+ */
+export declare function timeout(ms: number): Channel<void>;
+/**
+ * This function makes a ticker channel that sends at regular intervals.
+ *
+ * @example
+ * const tick = ticker(1000) // Every second
+ * for await (const t of tick) {
+ *   console.log('Tick:', t)
+ * }
+ */
+export declare function ticker(ms: number): Channel<number> & {
+  stop: () => void;
+};
+/**
+ * Pipeline: pipes values from input channel through transform to output channel.
+ *
+ * @example
+ * const input = channel<number>()
+ * const output = pipeline(input, (x) => x * 2)
+ *
+ * await input.send(5)
+ * const result = await output.receive() // 10
+ */
+export declare function pipeline<T, U>(input: Channel<T>, transform: (value: T) => U | Promise<U>, bufferSize?: number): Channel<U>;
+/**
+ * Fan-out: distributes values from one input channel to multiple output channels.
+ *
+ * @example
+ * const input = channel<number>()
+ * const [out1, out2, out3] = fanOut(input, 3)
+ *
+ * // Each output gets a copy of every input value
+ */
+export declare function fanOut<T>(input: Channel<T>, count: number, bufferSize?: number): Channel<T>[];
+/**
+ * Fan-in: merges multiple input channels into one output channel.
+ *
+ * @example
+ * const ch1 = channel<number>()
+ * const ch2 = channel<number>()
+ * const merged = fanIn(ch1, ch2)
+ *
+ * // merged receives values from both ch1 and ch2
+ */
+export declare function fanIn<T>(...inputs: Channel<T>[]): Channel<T>;
+/**
+ * Merge: like fanIn but closes output when first input closes.
+ *
+ * It takes one value at a time, from the inputs in turn. It keeps no receive on an input while
+ * it waits for the reader of the output. Thus each value of each input reaches the output one
+ * time, in the order of its input, or stays in its input.
+ */
+export declare function merge<T>(...inputs: Channel<T>[]): Channel<T>;
+/**
+ * Buffered channel with specified capacity.
+ */
+export declare function buffered<T>(capacity: number): Channel<T>;
+/**
+ * Unbuffered channel (rendezvous point).
+ * Sends block until receiver is ready.
+ */
+export declare function unbuffered<T>(): Channel<T>;
+/**
+ * Factory function to make a channel.
+ *
+ * @example
+ * const ch = channel<number>()
+ * const bufferedCh = channel<string>(10)
+ */
+export declare function channel<T>(bufferSize?: number): Channel<T>;
+/**
+ * WorkerPool: distributes work across multiple workers.
+ *
+ * @example
+ * const pool = workerPool(
+ *   jobChannel,
+ *   async (job) => await processJob(job),
+ *   { workers: 4 }
+ * )
+ *
+ * // 4 workers concurrently process jobs from jobChannel
+ */
+export declare function workerPool<T, R>(jobs: Channel<T>, worker: (job: T) => Promise<R>, options?: {
+  workers: number;
+  bufferSize?: number;
+}): Channel<R>;
+/**
+ * asSettled - The results of running promises, in the order that they settle.
+ *
+ * @example
+ * const pages = urls.map((url) => fetch(url));
+ * for await (const result of asSettled(pages)) {
+ *   if (result.status === "fulfilled") show(result.index, result.value);
+ *   else report(result.index, result.reason);
+ * }
+ */
+/** One result of `asSettled`: the index of its promise in the input, and how the promise settled. */
+export type Settled<T> = {
+  readonly index: number;
+} & PromiseSettledResult<T>;
+/**
+ * This function gives the result of each promise when it settles, in settle order, not in input
+ * order. The promises run already: this function starts nothing. Each result has the index of its
+ * promise in the input. A rejected promise gives `status: "rejected"` and its reason: the
+ * generator does not throw it. When the consumer stops early, the other promises continue, and
+ * their rejections are not reported as unhandled.
+ */
+export declare function asSettled<T>(promises: Iterable<Promise<T>>): AsyncGenerator<Settled<T>, void, undefined>;
+/**
+ * Functional operations for iterables (lazy sync transforms).
+ *
+ * This module gives Stream-like operations with lazy evaluation.
+ * All operations return generators for composability.
+ *
+ * @example
+ * const result = pipe(
+ *   [1, 2, 3, 4, 5],
+ *   map(x => x * 2),
+ *   filter(x => x > 5),
+ *   take(2),
+ *   toArray
+ * ) // [6, 8]
+ */
+/**
+ * This function maps each element through a function.
+ *
+ * @example
+ * const doubled = map([1, 2, 3], x => x * 2) // [2, 4, 6]
+ */
+export declare function map<T, U>(iterable: Iterable<T>, fn: (value: T, index: number) => U): Generator<U>;
+/**
+ * This function filters elements based on a predicate.
+ */
+export declare function filter<T>(iterable: Iterable<T>, predicate: (value: T, index: number) => boolean): Generator<T>;
+/**
+ * This function flatMaps each element to an iterable and flattens.
+ */
+export declare function flatMap<T, U>(iterable: Iterable<T>, fn: (value: T, index: number) => Iterable<U>): Generator<U>;
+/**
+ * This function flattens a nested iterable.
+ */
+export declare function flatten<T>(iterable: Iterable<Iterable<T>>): Generator<T>;
+/**
+ * This function takes the first n elements.
+ */
+export declare function take<T>(iterable: Iterable<T>, n: number): Generator<T>;
+/**
+ * This function skips the first n elements.
+ */
+export declare function skip<T>(iterable: Iterable<T>, n: number): Generator<T>;
+/**
+ * This function takes elements while predicate is true.
+ */
+export declare function takeWhile<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): Generator<T>;
+/**
+ * This function skips elements while predicate is true.
+ */
+export declare function skipWhile<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): Generator<T>;
+/**
+ * Concatenates multiple iterables.
+ */
+export declare function concat<T>(...iterables: Iterable<T>[]): Generator<T>;
+/**
+ * Zips multiple iterables together.
+ */
+export declare function zip<T extends any[]>(...iterables: { [K in keyof T]: Iterable<T[K]>; }): Generator<T>;
+/**
+ * Zips with index.
+ */
+export declare function enumerate<T>(iterable: Iterable<T>): Generator<[number, T]>;
+/**
+ * Chunks elements into arrays of specified size.
+ */
+export declare function chunk<T>(iterable: Iterable<T>, size: number): Generator<T[]>;
+/**
+ * This function makes a sliding window of specified size.
+ */
+export declare function window<T>(iterable: Iterable<T>, size: number): Generator<T[]>;
+/**
+ * Partitions elements into two arrays based on predicate.
+ */
+export declare function partition<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): [T[], T[]];
+/**
+ * This function reduces iterable to a single value.
+ */
+export declare function reduce<T, U>(iterable: Iterable<T>, fn: (acc: U, value: T, index: number) => U, initial: U): U;
+/**
+ * Scans (like reduce but emits intermediate results).
+ */
+export declare function scan<T, U>(iterable: Iterable<T>, fn: (acc: U, value: T) => U, initial: U): Generator<U>;
+/**
+ * This function sorts elements (materializes the iterable).
+ */
+export declare function sort<T>(iterable: Iterable<T>, compare?: (a: T, b: T) => number): Generator<T>;
+/**
+ * Reverses elements (materializes the iterable).
+ */
+export declare function reverse<T>(iterable: Iterable<T>): Generator<T>;
+/**
+ * This function removes duplicate elements (by reference or key function).
+ */
+export declare function distinct<T, K = T>(iterable: Iterable<T>, keyFn?: (value: T) => K): Generator<T>;
+/**
+ * This function removes consecutive duplicates.
+ */
+export declare function distinctConsecutive<T, K = T>(iterable: Iterable<T>, keyFn?: (value: T) => K): Generator<T>;
+/**
+ * This function does a side effect for each element. The stream does not change.
+ */
+export declare function tap<T>(iterable: Iterable<T>, fn: (value: T, index: number) => void): Generator<T>;
+/**
+ * This function gives true if any element matches the predicate.
+ */
+export declare function some<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): boolean;
+/**
+ * This function gives true if all elements match the predicate.
+ */
+export declare function every<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): boolean;
+/**
+ * This function gives true if no elements match the predicate.
+ */
+export declare function none<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): boolean;
+/**
+ * This function finds the first element matching the predicate.
+ */
+export declare function find<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): T | undefined;
+/**
+ * This function counts elements (optionally matching a predicate).
+ */
+export declare function count<T>(iterable: Iterable<T>, predicate?: (value: T) => boolean): number;
+/**
+ * This function gives the minimum element.
+ */
+export declare function min<T>(iterable: Iterable<T>, compare?: (a: T, b: T) => number): T | undefined;
+/**
+ * This function gives the maximum element.
+ */
+export declare function max<T>(iterable: Iterable<T>, compare?: (a: T, b: T) => number): T | undefined;
+/**
+ * This function gives the sum of elements.
+ */
+export declare function sum(iterable: Iterable<number>): number;
+/**
+ * This function gives the average of elements.
+ */
+export declare function average(iterable: Iterable<number>): number | undefined;
+/**
+ * This function collects elements into an array.
+ */
+declare function toArray$1<T>(iterable: Iterable<T>): T[];
+/**
+ * This function collects elements into a Set.
+ */
+declare function toSet$1<T>(iterable: Iterable<T>): Set<T>;
+/**
+ * This function collects elements into a Map.
+ */
+declare function toMap$1<T, K, V>(iterable: Iterable<T>, keyFn: (value: T) => K, valueFn: (value: T) => V): Map<K, V>;
+/**
+ * This function pipes a value through a series of transformations.
+ *
+ * @example
+ * const result = pipe(
+ *   [1, 2, 3, 4, 5],
+ *   (it) => map(it, x => x * 2),
+ *   (it) => filter(it, x => x > 5),
+ *   (it) => take(it, 2),
+ *   toArray
+ * ) // [6, 8]
+ */
+export declare function pipe<T>(value: T, ...fns: Array<(value: any) => any>): any;
+/**
+ * A Collector represents a mutable reduction operation.
+ *
+ * @template T - The type of input elements
+ * @template A - The mutable accumulation type
+ * @template R - The final result type
+ */
+export interface Collector<T, A, R> {
+  /**
+   * This value makes the initial accumulator.
+   */
+  supplier: () => A;
+  /**
+   * This value incorporates an element into the accumulator and gives the next accumulator. A mutable
+   * accumulator (a list, a map) gives itself. An immutable one (a count, a sum) gives the
+   * new value. (Before, the result was ignored, so every immutable collector - counting,
+   * summing, minBy, maxBy, reducing, first, last - given its seed: BUGS-2026-07 C12.)
+   */
+  accumulator: (acc: A, element: T) => A;
+  /**
+   * This value combines two accumulators (for parallel streams).
+   */
+  combiner?: (acc1: A, acc2: A) => A;
+  /**
+   * This value transforms the accumulator into the final result.
+   */
+  finisher: (acc: A) => R;
+}
+/**
+ * This function collects elements using a collector.
+ *
+ * @example
+ * const list = collect([1, 2, 3], toList())
+ * const set = collect([1, 2, 2, 3], toSet())
+ */
+export declare function collect<T, A, R>(iterable: Iterable<T>, collector: Collector<T, A, R>): R;
+/**
+ * This function collects elements into an ArrayList.
+ */
+declare function toList<T>(): Collector<T, ArrayList<T>, ArrayList<T>>;
+/**
+ * This function collects elements into a HashSet.
+ */
+declare function toSet<T>(): Collector<T, HashSet<T>, HashSet<T>>;
+/**
+ * This function collects elements into a native Array.
+ */
+declare function toArray<T>(): Collector<T, T[], T[]>;
+/**
+ * This function collects elements into a HashMap using key and value extractors.
+ */
+declare function toMap<T, K, V>(keyExtractor: (element: T) => K, valueExtractor: (element: T) => V): Collector<T, HashMap<K, V>, HashMap<K, V>>;
+/**
+ * This function groups elements by a classifier function.
+ *
+ * @example
+ * const byAge = collect(users, groupingBy(u => u.age))
+ * // Map<number, ArrayList<User>>
+ */
+export declare function groupingBy<T, K>(classifier: (element: T) => K): Collector<T, HashMap<K, ArrayList<T>>, HashMap<K, ArrayList<T>>>;
+/**
+ * Groups and transforms with a downstream collector.
+ *
+ * @example
+ * const countByAge = collect(
+ *   users,
+ *   groupingBy(u => u.age, counting())
+ * )
+ * // Map<number, number>
+ */
+export declare function groupingByWith<T, K, A, D>(classifier: (element: T) => K, downstream: Collector<T, A, D>): Collector<T, HashMap<K, A>, HashMap<K, D>>;
+/**
+ * Partitions elements into two groups based on a predicate.
+ *
+ * @example
+ * const partitioned = collect(
+ *   numbers,
+ *   partitioningBy(n => n % 2 === 0)
+ * )
+ * // Map<boolean, ArrayList<number>>
+ */
+export declare function partitioningBy<T>(predicate: (element: T) => boolean): Collector<T, HashMap<boolean, ArrayList<T>>, HashMap<boolean, ArrayList<T>>>;
+/**
+ * This function counts the number of elements.
+ */
+export declare function counting<T>(): Collector<T, number, number>;
+/**
+ * Sums numeric elements.
+ */
+export declare function summingNumber<T>(mapper: (element: T) => number): Collector<T, number, number>;
+/**
+ * Averages numeric elements.
+ */
+export declare function averagingNumber<T>(mapper: (element: T) => number): Collector<T, {
+  sum: number;
+  count: number;
+}, number>;
+/**
+ * This function finds the minimum element.
+ */
+export declare function minBy<T>(comparator: (a: T, b: T) => number): Collector<T, T | undefined, T | undefined>;
+/**
+ * This function finds the maximum element.
+ */
+export declare function maxBy<T>(comparator: (a: T, b: T) => number): Collector<T, T | undefined, T | undefined>;
+/**
+ * Joins elements into a string.
+ *
+ * @example
+ * const csv = collect(['a', 'b', 'c'], joining(', '))
+ * // "a, b, c"
+ *
+ * const bracketed = collect(
+ *   ['a', 'b', 'c'],
+ *   joining(', ', '[', ']')
+ * )
+ * // "[a, b, c]"
+ */
+export declare function joining<T>(delimiter?: string, prefix?: string, suffix?: string): Collector<T, string[], string>;
+/**
+ * This function applies a mapping function before collecting.
+ *
+ * @example
+ * const names = collect(
+ *   users,
+ *   mapping(u => u.name, toList())
+ * )
+ */
+export declare function mapping<T, U, A, R>(mapper: (element: T) => U, downstream: Collector<U, A, R>): Collector<T, A, R>;
+/**
+ * This function filters elements before collecting.
+ */
+export declare function filtering<T, A, R>(predicate: (element: T) => boolean, downstream: Collector<T, A, R>): Collector<T, A, R>;
+/**
+ * FlatMaps elements before collecting.
+ */
+export declare function flatMapping<T, U, A, R>(mapper: (element: T) => Iterable<U>, downstream: Collector<U, A, R>): Collector<T, A, R>;
+/**
+ * General reduction collector.
+ */
+export declare function reducing<T>(identity: T, reducer: (acc: T, element: T) => T): Collector<T, T, T>;
+/**
+ * Reducing with mapper.
+ */
+export declare function reducingWith<T, U>(identity: U, mapper: (element: T) => U, reducer: (acc: U, mapped: U) => U): Collector<T, U, U>;
+/**
+ * This function collects with two collectors and combines results.
+ *
+ * @example
+ * const stats = collect(
+ *   numbers,
+ *   teeing(
+ *     summingNumber(n => n),
+ *     counting(),
+ *     (sum, count) => ({ sum, count, avg: sum / count })
+ *   )
+ * )
+ */
+export declare function teeing<T, A1, A2, R1, R2, R>(collector1: Collector<T, A1, R1>, collector2: Collector<T, A2, R2>, combiner: (r1: R1, r2: R2) => R): Collector<T, [A1, A2], R>;
+/**
+ * This function collects the first element.
+ */
+export declare function first<T>(): Collector<T, T | undefined, T | undefined>;
+/**
+ * This function collects the last element.
+ */
+export declare function last<T>(): Collector<T, T | undefined, T | undefined>;
+/**
+ * This type makes summary statistics.
+ */
+export interface SummaryStatistics {
+  count: number;
+  sum: number;
+  min: number;
+  max: number;
+  average: number;
+}
+export declare function summarizingNumber<T>(mapper: (element: T) => number): Collector<T, Partial<SummaryStatistics>, SummaryStatistics>;
+/**
+ * Default equality using strict equality (===).
+ * Works for primitives and reference equality for objects.
+ */
+export declare const defaultEq: Eq<any>;
+/**
+ * Structural equality for objects (shallow comparison of properties).
+ * This function compares own enumerable properties using ===.
+ */
+export declare const shallowEq: Eq<any>;
+/**
+ * Deep structural equality (recursive comparison).
+ * This function handles nested objects and arrays.
+ */
+export declare const deepEq: Eq<any>;
+/**
+ * Equality by comparing a specific property.
+ *
+ * @example
+ * const userEq = eqBy<User, 'id'>('id')
+ * // or with accessor function:
+ * const userEq = eqBy<User>((u) => u.id)
+ */
+export declare const eqBy: <T, K extends keyof T = keyof T>(keyOrFn: K | ((value: T) => any)) => Eq<T>;
+/**
+ * Default hash function for primitives and objects.
+ * For objects, hashes the JSON string representation.
+ */
+export declare const defaultHash: Hash<any>;
+/**
+ * Hash function for strings using djb2 algorithm.
+ */
+export declare const hashString: (str: string) => number;
+/**
+ * Hash function for numbers.
+ */
+export declare const hashNumber: (num: number) => number;
+/**
+ * Combine multiple hash values.
+ * Useful for hashing objects with multiple fields.
+ *
+ * @example
+ * const pointHash: Hash<Point> = (p) =>
+ *   combineHashes(hashNumber(p.x), hashNumber(p.y))
+ */
+export declare const combineHashes: (...hashes: number[]) => number;
+/**
+ * Make a hash function that hashes by a specific property.
+ *
+ * @example
+ * const userHash = hashBy<User>((u) => u.id)
+ */
+export declare const hashBy: <T>(accessor: (value: T) => any) => Hash<T>;
+/**
+ * Natural ordering comparison for primitives.
+ * Numbers, strings, booleans, dates are compared naturally.
+ */
+export declare const defaultCompare: Compare<any>;
+/**
+ * Numeric comparison (for numbers).
+ */
+export declare const numberCompare: Compare<number>;
+/**
+ * String comparison using locale-aware sorting.
+ */
+export declare const stringCompare: Compare<string>;
+/**
+ * Case-insensitive string comparison.
+ */
+export declare const stringCompareIgnoreCase: Compare<string>;
+/**
+ * Date comparison.
+ */
+export declare const dateCompare: Compare<Date>;
+/**
+ * Boolean comparison (false < true).
+ */
+export declare const booleanCompare: Compare<boolean>;
+/**
+ * This function reverses a comparator.
+ *
+ * @example
+ * const descending = reversed(numberCompare)
+ */
+export declare const reversed: <T>(compare: Compare<T>) => Compare<T>;
+/**
+ * This function makes a comparator that compares by a specific property or function.
+ *
+ * @example
+ * const byAge = comparing<Person>((p) => p.age)
+ * const byName = comparing<Person, 'name'>('name')
+ */
+export declare const comparing: <T, K extends keyof T = keyof T>(keyOrFn: K | ((value: T) => any), compare?: Compare<any>) => Compare<T>;
+/**
+ * Chains comparators. If the first comparator gives 0 (equal),
+ * tries the next comparator, and so on.
+ *
+ * @example
+ * const userCompare = thenComparing(
+ *   comparing<User>('lastName'),
+ *   comparing<User>('firstName'),
+ *   comparing<User>('age')
+ * )
+ */
+export declare const thenComparing: <T>(...comparators: Compare<T>[]) => Compare<T>;
+/**
+ * This function makes a comparator that treats null/undefined as less than all other values.
+ *
+ * @example
+ * const compare = nullsFirst(numberCompare)
+ */
+export declare const nullsFirst: <T>(compare: Compare<T>) => Compare<T | null | undefined>;
+/**
+ * This function makes a comparator that treats null/undefined as greater than all other values.
+ *
+ * @example
+ * const compare = nullsLast(numberCompare)
+ */
+export declare const nullsLast: <T>(compare: Compare<T>) => Compare<T | null | undefined>;
+/**
+ * This function makes a comparator from a key extraction function.
+ * Elements are compared by their extracted keys.
+ *
+ * @example
+ * const byLength = comparingKey<string>((s) => s.length)
+ */
+export declare const comparingKey: <T, K>(keyExtractor: (value: T) => K, keyCompare?: Compare<K>) => Compare<T>;
+export declare function emptyList<T>(): List<T>;
+export declare function emptyQueue<T>(): Queue<T>;
+export declare function emptyMap<K, V>(): MapLike<K, V>;
+/**
+ * This function gives an immutable list containing only the specified element.
+ *
+ * @example
+ * const list = singletonList(42)
+ * list.size // 1
+ * list.get(0) // 42
+ * list.add(2) // Error: Cannot modify readonly collection
+ */
+export declare function singletonList<T>(element: T): List<T>;
+/**
+ * This function gives an immutable map containing only the specified key-value mapping.
+ */
+export declare function singletonMap<K, V>(key: K, value: V): MapLike<K, V>;
+/**
+ * This function gives an immutable list consisting of n copies of the specified element.
+ *
+ * @example
+ * const list = nCopies(5, 'hello')
+ * list.size // 5
+ * list.get(2) // 'hello'
+ */
+export declare function nCopies<T>(n: number, element: T): List<T>;
+/**
+ * This function makes a new ArrayList from the given elements.
+ *
+ * @example
+ * const list = listOf(1, 2, 3, 4, 5)
+ */
+export declare function listOf<T>(...elements: T[]): ArrayList<T>;
+/**
+ * This function makes a new ArrayDeque from the given elements.
+ */
+export declare function queueOf<T>(...elements: T[]): ArrayDeque<T>;
+/**
+ * This function makes a new HashMap from the given key-value pairs.
+ *
+ * @example
+ * const map = mapOf(['a', 1], ['b', 2], ['c', 3])
+ */
+export declare function mapOf<K, V>(...entries: [K, V][]): HashMap<K, V>;
+/**
+ * This function makes a new mutable ArrayList with optional initial elements.
+ *
+ * @example
+ * const list = mutableListOf(1, 2, 3)
+ * list.add(4)
+ */
+export declare function mutableListOf<T>(...elements: T[]): ArrayList<T>;
+/**
+ * This function makes a new mutable HashMap with optional initial entries.
+ */
+export declare function mutableMapOf<K, V>(...entries: [K, V][]): HashMap<K, V>;
+/**
+ * This function makes an immutable List from the given elements.
+ *
+ * @example
+ * const list = immutableListOf(1, 2, 3)
+ * list.get(0) // 1
+ * list.add(4) // Error: Cannot modify readonly collection
+ */
+export declare function immutableListOf<T>(...elements: T[]): List<T>;
+/**
+ * This function makes an immutable Map from the given entries.
+ */
+export declare function immutableMapOf<K, V>(...entries: [K, V][]): MapLike<K, V>;
+/**
+ * This function makes a list containing integers from start (inclusive) to end (exclusive).
+ *
+ * @example
+ * const list = range(0, 5) // [0, 1, 2, 3, 4]
+ * const list2 = range(10, 15) // [10, 11, 12, 13, 14]
+ */
+export declare function range(start: number, end: number, step?: number): ArrayList<number>;
+/**
+ * This function makes a list containing integers from 0 to n (exclusive).
+ *
+ * @example
+ * const list = rangeTo(5) // [0, 1, 2, 3, 4]
+ */
+export declare function rangeTo(n: number): ArrayList<number>;
+/**
+ * Builder for constructing lists with a fluent API.
+ *
+ * @example
+ * const list = buildList<number>((builder) => {
+ *   builder.add(1)
+ *   builder.add(2)
+ *   if (someCondition) {
+ *     builder.add(3)
+ *   }
+ * })
+ */
+export declare function buildList<T>(builder: (list: ArrayList<T>) => void): ArrayList<T>;
+/**
+ * Builder for constructing maps with a fluent API.
+ */
+export declare function buildMap<K, V>(builder: (map: HashMap<K, V>) => void): HashMap<K, V>;
+/**
+ * This function converts an iterable to an ArrayList.
+ *
+ * @example
+ * const set = new Set([1, 2, 3])
+ * const list = toList(set)
+ */
+declare function toList$1<T>(iterable: Iterable<T>): ArrayList<T>;
+/**
+ * This function converts an iterable to a HashMap using a key extractor function.
+ *
+ * @example
+ * const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ * const userMap = toMap(users, u => u.id)
+ */
+declare function toMap$2<T, K>(iterable: Iterable<T>, keyExtractor: (value: T) => K): HashMap<K, T>;
+declare function toMap$2<T, K, V>(iterable: Iterable<T>, keyExtractor: (value: T) => K, valueExtractor: (value: T) => V): HashMap<K, V>;
+/**
+ * This function groups elements by a key extractor function.
+ *
+ * @example
+ * const users = [
+ *   { age: 25, name: 'Alice' },
+ *   { age: 30, name: 'Bob' },
+ *   { age: 25, name: 'Charlie' }
+ * ]
+ * const byAge = groupBy(users, u => u.age)
+ * // Map { 25 => [Alice, Charlie], 30 => [Bob] }
+ */
+export declare function groupBy<T, K>(iterable: Iterable<T>, keyExtractor: (value: T) => K): HashMap<K, ArrayList<T>>;
+/**
+ * Checks if an index is within valid bounds [0, size).
+ * This function throws RangeError if out of bounds.
+ *
+ * @param index The index to check
+ * @param size The size of the collection
+ * @param collectionName Optional name for error message
+ * @throws RangeError if index is out of bounds
+ */
+export declare function checkBounds(index: number, size: number, collectionName?: string): void;
+/**
+ * Checks if an index is valid for insertion [0, size].
+ * In this function, index === size is correct for append operations.
+ *
+ * @param index The index to check
+ * @param size The size of the collection
+ * @param collectionName Optional name for error message
+ * @throws RangeError if index is out of bounds
+ */
+export declare function checkInsertBounds(index: number, size: number, collectionName?: string): void;
+/**
+ * Checks if a range [start, end) is valid.
+ *
+ * @param start Start index (inclusive)
+ * @param end End index (exclusive)
+ * @param size The size of the collection
+ * @param collectionName Optional name for error message
+ * @throws RangeError if range is invalid
+ */
+export declare function checkRangeBounds(start: number, end: number, size: number, collectionName?: string): void;
+/**
+ * This function finds the index of an element in an array using custom equality.
+ *
+ * @param array The array to search
+ * @param element The element to find
+ * @param eq Equality function
+ * @returns Index of element, or -1 if not found
+ */
+export declare function findIndex<T>(array: T[], element: T, eq: Eq<T>): number;
+/**
+ * This function finds the last index of an element in an array using custom equality.
+ *
+ * @param array The array to search
+ * @param element The element to find
+ * @param eq Equality function
+ * @returns Last index of element, or -1 if not found
+ */
+export declare function findLastIndex<T>(array: T[], element: T, eq: Eq<T>): number;
+/**
+ * Checks if an array contains an element using custom equality.
+ *
+ * @param array The array to search
+ * @param element The element to find
+ * @param eq Equality function
+ * @returns true if element is found
+ */
+export declare function arrayContains<T>(array: T[], element: T, eq: Eq<T>): boolean;
+/**
+ * This function removes the first occurrence of an element from an array.
+ *
+ * @param array The array to change
+ * @param element The element to remove
+ * @param eq Equality function
+ * @returns true if element was found and removed
+ */
+export declare function arrayRemove<T>(array: T[], element: T, eq: Eq<T>): boolean;
+/**
+ * This function removes all occurrences of an element from an array.
+ *
+ * @param array The array to change
+ * @param element The element to remove
+ * @param eq Equality function
+ * @returns Number of elements removed
+ */
+export declare function arrayRemoveAll<T>(array: T[], element: T, eq: Eq<T>): number;
+/**
+ * This function makes a simple iterator for an array.
+ *
+ * @param array The array to iterate
+ * @returns Iterator over the array
+ */
+export declare function arrayIterator<T>(array: T[]): Iterator<T>;
+/**
+ * This function makes a reversed iterator for an array.
+ *
+ * @param array The array to iterate
+ * @returns Reversed iterator over the array
+ */
+export declare function reverseArrayIterator<T>(array: T[]): Iterator<T>;
+/**
+ * This function makes sure that a value is not null or undefined.
+ *
+ * @param value The value to check
+ * @param message Error message
+ * @returns The non-null value
+ * @throws Error if value is null or undefined
+ */
+export declare function requireNonNull<T>(value: T | null | undefined, message?: string): T;
+/**
+ * This function makes sure that a collection is not empty.
+ *
+ * @param size Current size
+ * @param collectionName Optional name for error message
+ * @throws Error if collection is empty
+ */
+export declare function requireNonEmpty(size: number, collectionName?: string): void;
+/**
+ * This function clamps a value between min and max.
+ *
+ * @param value The value to clamp
+ * @param min Minimum value
+ * @param max Maximum value
+ * @returns Clamped value
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * This function calculates hash code for a string.
+ * This function uses Java's String.hashCode() algorithm.
+ *
+ * @param str The string to hash
+ * @returns Hash code
+ */
+export declare function stringHashCode(str: string): number;
+export { type BlockingQueue, type BoundedOptions, type DelayQueue, type Deque, type AsyncQueue$1 as IAsyncQueue, type PriorityQueue as IPriorityQueue, type KeyCheckOptions, type KeyedItem, type ListenerErrorHandler, type Point, PriorityQueue$1 as PriorityQueue, type Queue, type ReadonlyQueue, Set$1 as Set, type SummaryLocation, type SummaryMonoid, type SummarySearch, type SummarySpec, type TransferQueue, toArray as collectToArray, toList as collectToList, toMap as collectToMap, toSet as collectToSet, toMap$1 as iterToMap, toArray$1 as toArray, toList$1 as toList, toMap$2 as toMap, toSet$1 as toSet };
+//# sourceMappingURL=index.d.ts.map