@everyonesoftware/common 5.0.0 → 7.0.0

package/outputs/{sources.d.ts → sourceIndex.d.ts}

@@ -1,809 +1,112 @@
+import { C as CharacterWriteStream, A as AsyncResult, I as Iterable, f as JavascriptIterable, S as SyncResult, c as Iterator, E as EqualFunctions, T as ToStringFunctions, k as Type, g as JavascriptIterator, e as JavascriptAsyncIterator, P as PromiseAsyncResult, a as Comparable, h as JavascriptIteratorResult, b as Comparison, d as JavascriptAsyncIterable } from './characterWriteStream-ogvZec-U.js';
+export { J as JavascriptArray, i as JavascriptMap, j as JavascriptSet, l as as, m as asArray, n as asBoolean, o as asFunction, p as asFunctionWithParameterCount, q as asNull, r as asNumber, s as asObject, t as asObjectOrArrayOrNull, u as asString, v as getName, w as getParameterCount, x as getPropertyNames, y as hasFunction, z as hasProperty, B as instanceOf, D as instanceOfType, F as isArray, G as isAsyncIterable, H as isBoolean, K as isFunction, L as isFunctionWithParameterCount, M as isIterable, N as isJavascriptAsyncIterable, O as isJavascriptAsyncIterator, Q as isJavascriptIterable, R as isJavascriptIterator, U as isNull, V as isNumber, W as isObject, X as isObjectOrArrayOrNull, Y as isPromise, Z as isPromiseLike, _ as isString, $ as isUndefined, a0 as isUndefinedOrNull } from './characterWriteStream-ogvZec-U.js';
 import * as http from 'http';
 
-/**
- * A collection of parameters that can be passed to an assert error message function.
- */
-interface AssertMessageParameters {
-    /**
-     * The expected state.
-     */
-    expected: string;
-    /**
-     * The actual state.
-     */
-    actual: string;
-    /**
-     * A string representation of the expression that produced the actual state.
-     */
-    expression?: string;
-    /**
-     * A message that describes the failure.
-     */
-    message?: string;
-}
-
-/**
- * The result of comparing two values.
- */
-declare enum Comparison {
-    /**
-     * The left value is less than the right value.
-     */
-    LessThan = 0,
-    /**
-     * The two values are equal.
-     */
-    Equal = 1,
-    /**
-     * The left value is greater than the right value.
-     */
-    GreaterThan = 2
-}
-
-/**
- * An type that can be compared against another type.
- */
-declare abstract class Comparable<T> {
-    protected constructor();
-    /**
-     * Compare this value against the provided value.
-     * @param value The value to compare against.
-     */
-    abstract compareTo(value: T): Comparison;
-    /**
-     * Get whether this value is less than the provided value.
-     * @param value The value to compare against.
-     */
-    lessThan(value: T): boolean;
-    /**
-     * Get whether the left value is less than the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    static lessThan<T>(left: Comparable<T>, right: T): boolean;
-    /**
-     * Get whether this value is less than or equal to the provided value.
-     * @param value The value to compare against.
-     */
-    lessThanOrEqualTo(value: T): boolean;
-    /**
-     * Get whether the left value is less than or equal to the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    static lessThanOrEqualTo<T>(left: Comparable<T>, right: T): boolean;
-    /**
-     * Get whether this value equals the provided value.
-     * @param value The value to compare against.
-     */
-    equals(value: T): boolean;
-    /**
-     * Get whether the left value equals the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    static equals<T>(left: Comparable<T>, right: T): boolean;
-    /**
-     * Get whether this value is not equal to the provided value.
-     * @param value The value to compare against.
-     */
-    notEquals(value: T): boolean;
-    /**
-     * Get whether the left value is not equal to the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    static notEquals<T>(left: Comparable<T>, right: T): boolean;
-    /**
-     * Get whether this value is greater than or equal to the provided value.
-     * @param value The value to compare against.
-     */
-    greaterThanOrEqualTo(value: T): boolean;
-    /**
-     * Get whether the left value is greater than or equal to the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    static greaterThanOrEqualTo<T>(left: Comparable<T>, right: T): boolean;
-    /**
-     * Get whether this value is greater than the provided value.
-     * @param value The value to compare against.
-     */
-    greaterThan(value: T): boolean;
-    /**
-     * Get whether the left value is greater than the right value.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    static greaterThan<T>(left: Comparable<T>, right: T): boolean;
-}
-
-declare class SyncResult<T> implements AsyncResult<T> {
-    private value;
-    private error;
-    private constructor();
-    static create<T>(action: () => T): SyncResult<T>;
-    static value<T>(value: T): SyncResult<T>;
-    static error<T>(error: unknown): SyncResult<T>;
-    await(): T;
-    then<TResult1 = T, TResult2 = never>(onfullfilled?: ((value: T) => TResult1) | null, onrejected?: ((reason: unknown) => TResult2) | null): SyncResult<TResult1 | TResult2>;
-    then<TResult1 = T, TResult2 = never>(onfullfilled?: ((value: T) => (TResult1 | PromiseLike<TResult1>)) | null, onrejected?: ((reason: unknown) => (TResult2 | PromiseLike<TResult2>)) | null): SyncResult<TResult1 | TResult2>;
-    onValue(onValueFunction: (value: T) => void): SyncResult<T>;
-    onValue(onValueFunction: (value: T) => Promise<void>): PromiseAsyncResult<T>;
-    catch<TResult = never>(onrejected: (reason: unknown) => TResult): SyncResult<T | TResult>;
-    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): SyncResult<T | TResult> | PromiseAsyncResult<T | TResult>;
-    catch<TError, TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => TResult): SyncResult<T | TResult>;
-    catch<TError, TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => PromiseLike<TResult>): PromiseAsyncResult<T | TResult>;
-    onError(onErrorFunction: (reason: unknown) => void): SyncResult<T>;
-    onError(onErrorFunction: (reason: unknown) => PromiseLike<void>): PromiseAsyncResult<T>;
-    onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => void): SyncResult<T>;
-    onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => PromiseLike<void>): PromiseAsyncResult<T>;
-    convertError(convertErrorFunction: (reason: unknown) => unknown): SyncResult<T>;
-    convertError(onErrorFunction: (reason: unknown) => PromiseLike<unknown>): PromiseAsyncResult<T>;
-    convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => unknown): SyncResult<T>;
-    convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => PromiseLike<unknown>): PromiseAsyncResult<T>;
-    finally(onfinally?: (() => void) | null): SyncResult<T>;
-    finally(onfinally?: (() => Promise<void>) | null): PromiseAsyncResult<T>;
-    readonly [Symbol.toStringTag]: string;
-}
-
-/**
- * A collection of {@link Function}s that can be used to determine if two values are equal.
- */
-declare class EqualFunctions {
-    private readonly equalFunctions;
+declare class ANSIStyles {
     private constructor();
-    static create(): EqualFunctions;
-    private defaultEqualFunction;
-    /**
-     * Get whether the provided values are equal based on the registered equal {@link Function}s.
-     * @param left The left value in the comparison.
-     * @param right The right value in the comparison.
-     */
-    areEqual(left: unknown, right: unknown): SyncResult<boolean>;
-    add(equalFunction: (left: unknown, right: unknown) => (boolean | undefined)): this;
-}
-
-/**
- * The built-in {@link Array} type.
- *
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
- */
-type JavascriptArray<T> = Array<T>;
-/**
- * The built-in {@link Iterator} type.
- *
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#iterators
- */
-type JavascriptIterator<T> = Iterator<T>;
-/**
- * The built-in {@link IteratorResult} type.
- */
-type JavascriptIteratorResult<T> = IteratorResult<T, T>;
-/**
- * The built-in {@link Iterable} type.
- *
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#iterables
- */
-type JavascriptIterable<T> = Iterable<T>;
-/**
- * The built-in {@link Map} type.
- *
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
- */
-type JavascriptMap<TKey, TValue> = Map<TKey, TValue>;
-/**
- * The built-in {@link Map} type.
- *
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
- */
-declare const JavascriptMap: MapConstructor;
-/**
- * The built-in {@link AsyncIterator} type.
- *
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncIterator
- */
-type JavascriptAsyncIterator<T> = AsyncIterator<T>;
-interface JavascriptAsyncIterable<T> {
-    [Symbol.asyncIterator](): JavascriptAsyncIterator<T>;
+    private static color;
+    static black(text: string): string;
+    static red(text: string): string;
+    static green(text: string): string;
+    static yellow(text: string): string;
+    static blue(text: string): string;
 }
-/**
- * The built-in {@link Set} type.
- *
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
- */
-type JavascriptSet<T> = Set<T>;
-declare const JavascriptSet: SetConstructor;
 
-/**
- * A type that can be used to iterate over a collection.
- */
-declare abstract class Iterator$1<T> implements JavascriptIterable<T> {
-    /**
-     * Create a new {@link Iterator} that contains the provided values.
-     * @param values The values that the new {@link Iterator} will iterate over.
-     */
-    static create<T>(values: JavascriptIterator<T> | JavascriptIterable<T>): Iterator$1<T>;
-    /**
-     * Move to the next value in the collection. Return whether this {@link Iterator} points to a
-     * value after the move.
-     */
-    abstract next(): SyncResult<boolean>;
-    /**
-     * Get whether this {@link Iterator} has started iterating over the values in the collection.
-     */
-    abstract hasStarted(): boolean;
-    /**
-     * Get whether this {@link Iterator} currently points at a value in the collection.
-     */
-    abstract hasCurrent(): boolean;
-    /**
-     * Get the value that this {@link Iterator} points to.
-     */
-    abstract getCurrent(): T;
-    /**
-     * Move to the first value if this {@link Iterator} hasn't started yet.
-     * @returns This object for method chaining.
-     */
-    start(): SyncResult<this>;
-    /**
-     * Move the provided {@link Iterator} to its first value if it hasn't started yet.
-     */
-    static start<T, TIterator extends Iterator$1<T>>(iterator: TIterator): SyncResult<TIterator>;
-    /**
-     * Get the current value from this {@link Iterator} and advance this {@link Iterator} to the
-     * next value.
-     */
-    takeCurrent(): SyncResult<T>;
-    static takeCurrent<T>(iterator: Iterator$1<T>): SyncResult<T>;
-    [Symbol.iterator](): JavascriptIterator<T>;
-    /**
-     * Convert the provided {@link Iterator} to a {@link IteratorToJavascriptIteratorAdapter}.
-     * @param iterator The {@link Iterator} to convert.
-     */
-    static [Symbol.iterator]<T>(iterator: Iterator$1<T>): JavascriptIterator<T>;
-    /**
-     * Get whether this {@link Iterator} contains any values.
-     * Note: This may advance the {@link Iterator} to the first value if it hasn't been
-     * started yet.
-     */
-    any(): SyncResult<boolean>;
-    /**
-     * Get whether this {@link Iterator} contains any values.
-     * Note: This may advance the {@link Iterator} to the first value if it hasn't been
-     * started yet.
-     */
-    static any<T>(iterator: Iterator$1<T>): SyncResult<boolean>;
-    /**
-     * Get the number of values in this {@link Iterator}.
-     * Note: This will consume all of the values in this {@link Iterator}.
-     */
-    getCount(): SyncResult<number>;
-    /**
-     * Get the number of values in the provided {@link Iterator}.
-     * Note: This will consume all of the values in the provided {@link Iterator}.
-     */
-    static getCount<T>(iterator: Iterator$1<T>): SyncResult<number>;
-    /**
-     * Get all of the remaining values in this {@link Iterator} in a {@link T} {@link Array}.
-     */
-    toArray(): SyncResult<T[]>;
-    /**
-     * Get all of the remaining values in the provided {@link Iterator} in a {@link T}
-     * {@link Array}.
-     */
-    static toArray<T>(iterator: Iterator$1<T>): SyncResult<T[]>;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator$1<T>;
-    static concatenate<T>(iterator: Iterator$1<T>, ...toConcatenate: JavascriptIterable<T>[]): Iterator$1<T>;
-    /**
-     * Get an {@link Iterator} that will only return values that match the provided condition.
-     * @param condition The condition to run against each of the values in this {@link Iterator}.
-     */
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterator$1<T>;
-    static where<T>(iterator: Iterator$1<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): Iterator$1<T>;
-    /**
-     * Get a {@link MapIterator} that will map all {@link T} values from this {@link Iterator} to
-     * {@link TOutput} values.
-     * @param mapping The mapping that maps {@link T} values to {@link TOutput} values.
-     */
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator$1<TOutput>;
-    static map<T, TOutput>(iterator: Iterator$1<T>, mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
-    static flatMap<T, TOutput>(iterator: Iterator$1<T>, mapping: (value: T) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
-    /**
-     * Get an {@link Iterator} that will filter this {@link Iterator} to only the values that are
-     * instances of {@link U} based on the provided type check {@link Function}.
-     * @param typeCheck The {@link Function} that will be used to determine if values are of type
-     * {@link U}.
-     */
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator$1<U>;
-    static whereInstanceOf<T, U extends T>(iterator: Iterator$1<T>, typeCheck: (value: T) => value is U): Iterator$1<U>;
-    /**
-     * Get an {@link Iterator} that will filter this {@link Iterator} to only the values that are
-     * instances of the provided {@link Type}.
-     * @param type The type of values to return from the new {@link Iterator}.
-     */
-    whereInstanceOfType<U extends T>(type: Type<U>): Iterator$1<U>;
-    static whereInstanceOfType<T, U extends T>(iterator: Iterator$1<T>, type: Type<U>): Iterator$1<U>;
-    /**
-     * If the condition function is undefined, then this function will return the first value in
-     * this {@link Iterator}. If this condition function is provided, then this function will return
-     * the first value that matches the provided condition.
-     * @param condition The condition that the returned value must satisfy.
-     */
-    first(condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
-    /**
-     * If the condition function is undefined, then this function will return the first value in
-     * the {@link Iterator}. If this condition function is provided, then this function will return
-     * the first value that matches the provided condition.
-     * @param iterator The {@link Iterator} to get the first value from.
-     */
-    static first<T>(iterator: Iterator$1<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
-    /**
-     * If the condition function is undefined, then this function will return the last value in this
-     * {@link Iterator}. If this condition function is provided, then this function will return the
-     * last value that matches the provided condition.
-     * @param condition The condition that the returned value must satisfy.
-     */
-    last(condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
-    /**
-     * If the condition function is undefined, then this function will return the last value in the
-     * {@link Iterator}. If this condition function is provided, then this function will return the
-     * last value that matches the provided condition.
-     * @param iterator The {@link Iterator} to get the last value from.
-     */
-    static last<T>(iterator: Iterator$1<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
-    /**
-     * Find the maximum value in the provided {@link Iterator}.
-     * @param iterator The values to find the maximum of.
-     */
-    static findMaximum<T extends Comparable<T>>(iterator: JavascriptIterator<T> | Iterator$1<T>): SyncResult<T>;
-    /**
-     * Get a new {@link Iterator} that wraps around this {@link Iterator} and only
-     * returns a maximum number of values from this {@link Iterator}.
-     * @param maximumToTake The maximum number of values to take from this {@link Iterator}.
-     */
-    take(maximumToTake: number): Iterator$1<T>;
-    static take<T>(iterator: Iterator$1<T>, maximumToTake: number): Iterator$1<T>;
-    /**
-     * Get a new {@link Iterator} that wraps around this {@link Iterator} and will skip the initial
-     * provided number of values before beginning to return values.
-     * @param maximumToSkip The maximum number of values to skip from this {@link Iterator}.
-     */
-    skip(maximumToSkip: number): Iterator$1<T>;
-    static skip<T>(iterator: Iterator$1<T>, maximumToSkip: number): Iterator$1<T>;
+declare class CharacterTable {
+    private constructor();
+    static create(): CharacterTable;
 }
 
-/**
- * A collection of {@link ToStringFunction}s.
- */
-declare class ToStringFunctions {
-    private readonly functions;
+declare class IndentedCharacterWriteStream extends CharacterWriteStream {
+    private readonly innerStream;
+    private currentIndentationList;
+    private currentIndentation;
+    private singleIndent;
+    private atLineStart;
     private constructor();
-    static create(): ToStringFunctions;
-    private defaultToString;
-    /**
-     * Get the {@link String} representation of the value with the registered
-     * {@link ToStringFunction}s.
-     * @param value The value to get the {@link String} representation of.
-     */
-    toString(value: unknown): string;
-    add(toStringFunction: (value: unknown) => (string | undefined)): this;
-    add<T>(typeCheckFunction: (value: unknown) => value is T, typedToStringFunction: (value: T) => string): this;
-    private iterableToString;
-    private mapToString;
-    private setToString;
+    static create(innerStream: CharacterWriteStream): IndentedCharacterWriteStream;
+    getSingleIndent(): string;
+    setSingleIndent(singleIndent: string): this;
+    getCurrentIndentationCount(): number;
+    getCurrentIndentation(): string;
+    addIndentation(singleIndent?: string): this;
+    removeIndentation(): string;
+    indent(action: () => (void | number | PromiseLike<void | number>)): AsyncResult<number>;
+    indent(singleIndent: string, action: () => (void | number | PromiseLike<void | number>)): AsyncResult<number>;
+    writeString(text: string): AsyncResult<number>;
 }
 
 /**
- * An object that can be iterated over.
+ * A container that can be accessed using indexes.
  */
-declare abstract class Iterable$1<T> implements JavascriptIterable<T> {
-    static create<T>(values?: JavascriptIterable<T>): Iterable$1<T>;
+declare abstract class Indexable<T> implements Iterable<T> {
+    static create<T>(values?: JavascriptIterable<T>): Indexable<T>;
     /**
-     * Iterate over the values in this {@link Iterable}.
+     * Get the value at the provided index.
+     * @param index The index of the value to return.
      */
-    abstract iterate(): Iterator$1<T>;
-    [Symbol.iterator](): JavascriptIterator<T>;
-    static [Symbol.iterator]<T>(iterable: Iterable$1<T>): JavascriptIterator<T>;
+    abstract get(index: number): SyncResult<T>;
     /**
-     * Get all of the values in this {@link Iterable} in an {@link Array}.
+     * Iterate over the values in this {@link Indexable}.
      */
+    abstract iterate(): Iterator<T>;
     toArray(): SyncResult<T[]>;
-    /**
-     * Get all of the values in the provided {@link Iterable} in an {@link Array}.
-     */
-    static toArray<T>(iterable: Iterable$1<T>): SyncResult<T[]>;
-    /**
-     * Get whether this {@link Iterable} contains any values.
-     */
+    static toArray<T>(indexable: Indexable<T>): SyncResult<T[]>;
     any(): SyncResult<boolean>;
-    /**
-     * Get whether the provided {@link JavascriptIterable} contains any values.
-     */
-    static any<T>(iterable: JavascriptIterable<T>): SyncResult<boolean>;
-    /**
-     * Get the number of values in this {@link Iterable}.
-     */
+    static any<T>(indexable: Indexable<T>): SyncResult<boolean>;
     getCount(): SyncResult<number>;
-    /**
-     * Get the number of values in the provided {@link Iterable}.
-     */
-    static getCount<T>(iterable: Iterable$1<T>): SyncResult<number>;
-    /**
-     * Get whether this {@link Iterable} is equal to the provided {@link Iterable}.
-     * @param right The {@link Iterable} to compare against this {@link Iterable}.
-     * @param equalFunctions The optional {@link EqualFunctions} to use to determine if the two
-     * {@link Iterable}s are equal.
-     */
+    static getCount<T>(indexable: Indexable<T>): SyncResult<number>;
     equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    static equals<T>(left: JavascriptIterable<T>, right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    /**
-     * Get the {@link String} representation of this {@link Iterable}.
-     */
+    static equals<T>(left: Indexable<T>, right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    /**
-     * Get the {@link String} representation of the provided {@link Iterable}.
-     */
-    static toString<T>(iterable: Iterable$1<T>, toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    static concatenate<T>(iterable: Iterable$1<T>, ...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    /**
-     * Get a {@link MapIterable} that maps all of the {@link T} values in this {@link Iterable} to
-     * {@link TOutput} values.
-     * @param mapping The mapping function to use to convert values of type {@link T} to
-     * {@link TOutput}.
-     */
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    /**
-     * Get a {@link MapIterable} that maps all of the {@link T} values in the provided
-     * {@link Iterable} to {@link TOutput} values.
-     * @param mapping The mapping function to use to convert values of type {@link T} to
-     * {@link TOutput}.
-     */
-    static map<TInput, TOutput>(iterable: Iterable$1<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    static flatMap<T, TOutput>(iterable: Iterable$1<T>, mapping: (value: T) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    /**
-     * Get an {@link Iterable} that contains values from this {@link Iterable} that match the
-     * provided condition.
-     * @param condition The condition to run against each of the values in this {@link Iterable}.
-     */
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    /**
-     * Get an {@link Iterable} that contains values from the provided {@link Iterable} that match
-     * the provided condition.
-     * @param iterable The {@link Iterable} to get values from.
-     * @param condition The condition that the values must match to be contained in the new
-     * {@link Iterable}.
-     */
-    static where<T>(iterable: JavascriptIterable<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    /**
-     * Get an {@link Iterable} that contains values from this {@link Iterable} that match the
-     * provided {@link Type} or type check function.
-     * @param typeOrTypeCheck The {@link Type} or type check function that returned values must
-     * match.
-     */
-    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable$1<TOutput>;
-    /**
-     * Get an {@link Iterable} that contains values from the provided {@link Iterable} that match
-     * the provided {@link Type} or type check function.
-     * @param iterable The {@link Iterable} to get values from.
-     * @param typeOrTypeCheck The {@link Type} or type check function that returned values must
-     * match.
-     */
-    static instanceOf<TInput, TOutput extends TInput>(iterable: JavascriptIterable<TInput>, typeOrTypeCheck: Type<TOutput> | ((value: TInput) => value is TOutput)): Iterable$1<TOutput>;
-    /**
-     * Get the first value in this {@link Iterable}.
-     */
-    first(condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
-    /**
-     * Get the first value from the provided {@link JavascriptIterable}.
-     * @param iterable The {@link JavascriptIterable} to get the first value from.
-     */
-    static first<T>(iterable: JavascriptIterable<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
-    /**
-     * Get the last value in this {@link Iterable}.
-     */
-    last(condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
-    /**
-     * Get the last value from the provided {@link JavascriptIterable}.
-     * @param iterable The {@link JavascriptIterable} to get the last value from.
-     */
-    static last<T>(iterable: JavascriptIterable<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
-    /**
-     * Find the maximum value in the provided {@link Iterable}.
-     * @param iterable The values to find the maximum of.
-     */
-    static findMaximum<T extends Comparable<T>>(iterable: JavascriptIterable<T> | Iterable$1<T>): SyncResult<T>;
+    static toString<T>(indexable: Indexable<T>, toStringFunctions?: ToStringFunctions): string;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    static concatenate<T>(indexable: Indexable<T>, ...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    static map<TInput, TOutput>(indexable: Indexable<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    static flatMap<TInput, TOutput>(indexable: Indexable<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    static where<T>(indexable: Indexable<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>;
+    static instanceOf<TInput, TOutput extends TInput>(indexable: Indexable<TInput>, typeOrTypeCheck: Type<TOutput> | ((value: TInput) => value is TOutput)): Iterable<TOutput>;
+    first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
+    static first<T>(indexable: Indexable<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
+    last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
+    static last<T>(indexable: Indexable<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
+    [Symbol.iterator](): JavascriptIterator<T>;
+    static [Symbol.iterator]<T>(indexable: Indexable<T>): JavascriptIterator<T>;
     contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    static contains<T>(iterable: Iterable$1<T>, value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static contains<T>(indexable: Indexable<T>, value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
 }
 
 /**
- * A {@link Type} that can be used to pass types as parameters.
- */
-type Type<T> = Function & {
-    prototype: T;
-};
-/**
- * Get whether the provided value is an instance of {@link Type} {@link T}.
- * @param typeOrTypeCheck The {@link Type} to look for or type check {@link Function} to determine
- * if the provided value is a {@link T}.
- * @param value The value to check.
- */
-declare function instanceOf<T>(value: unknown, typeCheck: (value: unknown) => value is T): value is T;
-/**
- * Get whether the provided value is an instance of {@link Type} {@link T}.
- * @param typeOrTypeCheck The {@link Type} to look for or type check {@link Function} to determine
- * if the provided value is a {@link T}.
- * @param value The value to check.
- */
-declare function instanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T): value is T;
-/**
- * Get whether the provided value is an instance of the provided {@link Type}. This will return
- * false if value only implements the provided {@link Type} but doesn't extend it.
- * @param value The value to check.
- * @param type The {@link Type} to see if value is an instance of.
- */
-declare function instanceOfType<T>(value: unknown, type: Type<T>): value is T;
-/**
- * If the provided {@link value} is of type {@link T} (according to the provided {@link typeCheck}),
- * then return the {@link value}. Otherwise return undefined.
- * @param value The value to check.
- * @param typeOrTypeCheck The {@link Type} to look for or type check {@link Function} to determine
- * if the provided value is a {@link T}.
- */
-declare function as<T>(value: unknown, typeOrTypeCheck: Type<T> | ((value: unknown) => value is T)): T | undefined;
-/**
- * Get whether the provided value is undefined.
- * @param value The value to check.
- */
-declare function isUndefined(value: unknown): value is undefined;
-/**
- * Get whether the provided value is null.
- * @param value The value to check.
- */
-declare function isNull(value: unknown): value is null;
-/**
- * Return the provided value if it is null, otherwise return undefined.
- * @param value The value to check.
- */
-declare function asNull(value: unknown): null | undefined;
-/**
- * Get whether the provided value is undefined or null.
- * @param value The value to check.
- */
-declare function isUndefinedOrNull(value: unknown): value is undefined | null;
-/**
- * Get whether the provided value is a {@link boolean}.
- * @param value The value to check.
- */
-declare function isBoolean(value: unknown): value is boolean;
-/**
- * Return the provided value if it is a boolean, otherwise return undefined.
- * @param value The value to check.
- */
-declare function asBoolean(value: unknown): boolean | undefined;
-/**
- * Get whether the provided value is a {@link number}.
- * @param value The value to check.
- */
-declare function isNumber(value: unknown): value is number;
-/**
- * Return the provided value if it is a number, otherwise return undefined.
- * @param value The value to check.
- */
-declare function asNumber(value: unknown): number | undefined;
-/**
- * Get whether the provided value is a {@link string}.
- * @param value The value to check.
- */
-declare function isString(value: unknown): value is string;
-/**
- * Return the provided value if it is a string, otherwise return undefined.
- * @param value The value to check.
- */
-declare function asString(value: unknown): string | undefined;
-/**
- * Get whether the provided value is a {@link function}.
- * @param value The value to check.
- */
-declare function isFunction(value: unknown): value is Function;
-/**
- * Return the provided value if it is a function, otherwise return undefined.
- * @param value The value to check.
- */
-declare function asFunction(value: unknown): Function | undefined;
-/**
- * Get the number of parameters that the provided {@link Function} takes.
- * @param value The {@link Function} to get the parameter count for.
- */
-declare function getParameterCount(value: Function): number;
-/**
- * Get whether the provided value is a function with the provided parameter count.
- * @param value The value to check.
- * @param parameterCount The number of parameters the function must have.
- */
-declare function isFunctionWithParameterCount(value: unknown, parameterCount: number): value is Function;
-/**
- * Return the provided value if it is a function with the provided {@link parameterCount}, otherwise
- * return undefined.
- * @param value The value to check.
- */
-declare function asFunctionWithParameterCount(value: unknown, parameterCount: number): Function | undefined;
-/**
- * Get whether the provided value is an {@link Array}.
- * @param value The value to check.
- */
-declare function isArray(value: unknown): value is unknown[];
-/**
- * Return the provided value if it is an array, otherwise return undefined.
- * @param value The value to check.
- */
-declare function asArray(value: unknown): unknown[] | undefined;
-/**
- * Get whether the provided value is an {@link Object} or is null.
- * @param value The value to check.
- */
-declare function isObjectOrArrayOrNull(value: unknown): value is {} | unknown[] | null;
-/**
- * Return the provided value if it is an array, otherwise return undefined.
- * @param value The value to check.
- */
-declare function asObjectOrArrayOrNull(value: unknown): {} | unknown[] | null | undefined;
-/**
- * Get whether the provided value is an {@link Object}.
- * @param value The value to check.
- * @returns
- */
-declare function isObject(value: unknown): value is {};
-/**
- * Return the provided value if it is an {@link Object}, otherwise return undefined.
- * @param value The value to check.
- */
-declare function asObject(value: unknown): {} | undefined;
-/**
- * Get an {@link Iterator} that can be used to iterate through the properties of the provided value.
- * @param value The value to iterate over.
- */
-declare function getPropertyNames(value: {}): Iterable$1<string>;
-/**
- * Get whether the provided value has a property with the provided key.
- * @param value The value to check.
- * @param propertyKey The key of the property to look for.
- */
-declare function hasProperty<TValue, TPropertyKey extends PropertyKey>(value: TValue, propertyKey: TPropertyKey): value is TValue & Record<TPropertyKey, unknown>;
-/**
- * Get whether the value has a function with the provided name.
- * @param value The value to check.
- * @param functionName The name of the function to look for.
- */
-declare function hasFunction<TValue, TPropertyKey extends PropertyKey>(value: TValue, functionName: TPropertyKey, parameterCount?: number): value is TValue & Record<TPropertyKey, Function>;
-/**
- * Get whether the provided value is a {@link JavascriptIterator}.
- * @param value The value to check.
- */
-declare function isJavascriptIterator<T>(value: unknown): value is JavascriptIterator<T>;
-/**
- * Get whether the provided value is a {@link JavascriptIterable}.
- * @param value The value to check.
- */
-declare function isJavascriptIterable<T>(value: unknown): value is JavascriptIterable<T>;
-declare function isIterable<T>(value: unknown): value is Iterable$1<T>;
-/**
- * Get whether the provided value is a {@link JavascriptAsyncIterator}.
- * @param value The value to check.
- */
-declare function isJavascriptAsyncIterator<T>(value: unknown): value is JavascriptAsyncIterator<T>;
-/**
- * Get whether the provided value is a {@link JavascriptAsyncIterable}.
- * @param value The value to check.
- */
-declare function isJavascriptAsyncIterable<T>(value: unknown): value is JavascriptAsyncIterable<T>;
-declare function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T>;
-/**
- * Get the name of the provided {@link Type}.
- * @param type The {@link Type} to get the name of.
- */
-declare function getName(type: Type<unknown>): string;
-declare function isPromiseLike<T>(value: unknown): value is PromiseLike<T>;
-declare function isPromise<T>(value: unknown): value is Promise<T>;
-
-/**
- * A result object that adds extra behavior beyond the standard {@link Promise}.
+ * A collection of parameters that can be passed to an assert error message function.
  */
-declare abstract class AsyncResult<T> implements Promise<T> {
-    static create<T>(action: () => (T | Promise<T>)): AsyncResult<T>;
-    static create<T>(promise: Promise<T>): AsyncResult<T>;
-    /**
-     * Create a new {@link AsyncResult} that contains the provided value.
-     * @param value The value to wrap in a {@link AsyncResult}.
-     */
-    static value<T>(value: T): AsyncResult<T>;
-    /**
-     * Create a new {@link AsyncResult} that contains the provided error.
-     * @param error The error to wrap in a {@link AsyncResult}.
-     */
-    static error<T>(error: Error): AsyncResult<T>;
-    static yield(): AsyncResult<void>;
-    /**
-     * Get a {@link AsyncResult} that runs the provided function if this {@link AsyncResult} is successful.
-     * @param thenFunction The function to run if this {@link AsyncResult} is successful.
-     */
-    abstract then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): AsyncResult<TResult1 | TResult2>;
-    /**
-     * Run the provided onValueFunction if this {@link AsyncResult} is successful. The value or error
-     * contained by this {@link AsyncResult} will be contained by the returned {@link AsyncResult}.
-     * @param onValueFunction The function to run if this {@link AsyncResult} is successful.
-     */
-    abstract onValue(onValueFunction: (value: T) => (void | Promise<void>)): AsyncResult<T>;
-    /**
-     * Run the provided catchFunction if this {@link AsyncResult} contains an error.
-     * @param catchFunction The function to run if an error is caught.
-     */
-    abstract catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): AsyncResult<T | TResult>;
-    /**
-     * Run the provided catchFunction if this {@link AsyncResult} contains an error of the provided type.
-     * @param errorType The type of error to catch.
-     * @param catchFunction The function to run if the error is caught.
-     */
-    abstract catch<TError, TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => (TResult | PromiseLike<TResult>)): AsyncResult<T | TResult>;
+interface AssertMessageParameters {
     /**
-     * Run the provided onErrorFunction if this {@link AsyncResult} contains an error.
-     * @param onErrorFunction The function to run if an error is found.
+     * The expected state.
      */
-    abstract onError(onErrorFunction: (reason: unknown) => (void | PromiseLike<void>)): AsyncResult<T>;
+    expected: string;
     /**
-     * Run the provided onErrorFunction if this {@link AsyncResult} contains an error of the provided
-     * type.
-     * @param errorType The type of error to respond to.
-     * @param onErrorFunction The function to run if the error is found.
+     * The actual state.
      */
-    abstract onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => (void | PromiseLike<void>)): AsyncResult<T>;
+    actual: string;
     /**
-     * Run the provided convertErrorFunction if this {@link AsyncResult} contains an error. The value
-     * returned from the convertErrorFunction will be the error for the returned {@link AsyncResult}.
-     * @param convertErrorFunction The function that will return the new error.
+     * A string representation of the expression that produced the actual state.
      */
-    abstract convertError(convertErrorFunction: (reason: unknown) => (unknown | PromiseLike<unknown>)): AsyncResult<T>;
+    expression?: string;
     /**
-     * Run the provided convertErrorFunction if this {@link AsyncResult} contains an error of the
-     * provided type. The value returned from the convertErrorFunction will be the error for the
-     * returned {@link AsyncResult}.
-     * @param errorType The type of error to respond to.
-     * @param convertErrorFunction The function that will return the new error.
+     * A message that describes the failure.
      */
-    abstract convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => (unknown | PromiseLike<unknown>)): AsyncResult<T>;
-    abstract finally(onfinally?: (() => (void | Promise<void>)) | null): AsyncResult<T>;
-    readonly abstract [Symbol.toStringTag]: string;
-}
-
-declare class PromiseAsyncResult<T> implements AsyncResult<T> {
-    private readonly promise;
-    private constructor();
-    static create<T>(action: () => (T | Promise<T>)): PromiseAsyncResult<T>;
-    static create<T>(promise: Promise<T>): PromiseAsyncResult<T>;
-    static value<T>(value: T): PromiseAsyncResult<T>;
-    static error<T>(error: unknown): PromiseAsyncResult<T>;
-    static yield(): PromiseAsyncResult<void>;
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseAsyncResult<TResult1 | TResult2>;
-    onValue(onValueFunction: (value: T) => (void | Promise<void>)): PromiseAsyncResult<T>;
-    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): PromiseAsyncResult<T | TResult>;
-    catch<TError, TResult = never>(errorType: Type<TError>, onrejected: (reason: TError) => (TResult | PromiseLike<TResult>)): PromiseAsyncResult<T | TResult>;
-    onError(onErrorFunction: (reason: unknown) => (void | PromiseLike<void>)): PromiseAsyncResult<T>;
-    onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => (void | PromiseLike<void>)): PromiseAsyncResult<T>;
-    convertError(convertErrorFunction: (reason: unknown) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>;
-    convertError<TError>(errorType: Type<TError>, convertErrorFunction: (reason: TError) => (unknown | PromiseLike<unknown>)): PromiseAsyncResult<T>;
-    finally(onfinally?: (() => (void | Promise<void>)) | null): PromiseAsyncResult<T>;
-    readonly [Symbol.toStringTag]: string;
+    message?: string;
 }
 
 /**
  * A type that can be used to asynchronously iterate over a collection.
  */
-declare abstract class AsyncIterator$1<T> {
-    static create<T>(iterator: JavascriptAsyncIterator<T>): AsyncIterator$1<T>;
+declare abstract class AsyncIterator<T> {
+    static create<T>(iterator: JavascriptAsyncIterator<T>): AsyncIterator<T>;
     /**
      * Move to the next value in the collection. Return whether this {@link AsyncIterator} points to
      * a value after the move.
@@ -829,19 +132,19 @@ declare abstract class AsyncIterator$1<T> {
     /**
      * Move the provided {@link AsyncIterator} to its first value if it hasn't started yet.
      */
-    static start<T, TIterator extends AsyncIterator$1<T>>(iterator: TIterator): PromiseAsyncResult<TIterator>;
+    static start<T, TIterator extends AsyncIterator<T>>(iterator: TIterator): PromiseAsyncResult<TIterator>;
     /**
      * Get the current value from this {@link AsyncIterator} and advance this {@link AsyncIterator} to the
      * next value.
      */
     takeCurrent(): PromiseAsyncResult<T>;
-    static takeCurrent<T>(iterator: AsyncIterator$1<T>): PromiseAsyncResult<T>;
+    static takeCurrent<T>(iterator: AsyncIterator<T>): PromiseAsyncResult<T>;
     [Symbol.asyncIterator](): JavascriptAsyncIterator<T>;
     /**
      * Convert the provided {@link AsyncIterator} to a {@link IteratorToJavascriptIteratorAdapter}.
      * @param iterator The {@link AsyncIterator} to convert.
      */
-    static [Symbol.asyncIterator]<T>(iterator: AsyncIterator$1<T>): JavascriptAsyncIterator<T>;
+    static [Symbol.asyncIterator]<T>(iterator: AsyncIterator<T>): JavascriptAsyncIterator<T>;
     /**
      * Get whether this {@link AsyncIterator} contains any values.
      * Note: This may advance the {@link AsyncIterator} to the first value if it hasn't been
@@ -853,7 +156,7 @@ declare abstract class AsyncIterator$1<T> {
      * Note: This may advance the {@link AsyncIterator} to the first value if it hasn't been
      * started yet.
      */
-    static any<T>(iterator: AsyncIterator$1<T>): PromiseAsyncResult<boolean>;
+    static any<T>(iterator: AsyncIterator<T>): PromiseAsyncResult<boolean>;
     /**
      * Get the number of values in this {@link AsyncIterator}.
      * Note: This will consume all of the values in this {@link AsyncIterator}.
@@ -863,7 +166,7 @@ declare abstract class AsyncIterator$1<T> {
      * Get the number of values in the provided {@link AsyncIterator}.
      * Note: This will consume all of the values in the provided {@link AsyncIterator}.
      */
-    static getCount<T>(iterator: AsyncIterator$1<T>): PromiseAsyncResult<number>;
+    static getCount<T>(iterator: AsyncIterator<T>): PromiseAsyncResult<number>;
     /**
      * Get all of the remaining values in this {@link AsyncIterator} in a {@link T} {@link Array}.
      */
@@ -872,35 +175,35 @@ declare abstract class AsyncIterator$1<T> {
      * Get all of the remaining values in the provided {@link AsyncIterator} in a {@link T}
      * {@link Array}.
      */
-    static toArray<T>(iterator: AsyncIterator$1<T>): PromiseAsyncResult<T[]>;
+    static toArray<T>(iterator: AsyncIterator<T>): PromiseAsyncResult<T[]>;
     /**
      * Get an {@link AsyncIterator} that will only return values that match the provided condition.
      * @param condition The condition to run against each of the values in this {@link AsyncIterator}.
      */
-    where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator$1<T>;
-    static where<T>(iterator: AsyncIterator$1<T>, condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator$1<T>;
+    where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator<T>;
+    static where<T>(iterator: AsyncIterator<T>, condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator<T>;
     /**
      * Get a {@link MapIterator} that will map all {@link T} values from this {@link AsyncIterator} to
      * {@link TOutput} values.
      * @param mapping The mapping that maps {@link T} values to {@link TOutput} values.
      */
-    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator$1<TOutput>;
-    static map<T, TOutput>(iterator: AsyncIterator$1<T>, mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator$1<TOutput>;
+    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>;
+    static map<T, TOutput>(iterator: AsyncIterator<T>, mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>;
     /**
      * Get an {@link AsyncIterator} that will filter this {@link AsyncIterator} to only the values that are
      * instances of {@link U} based on the provided type check {@link Function}.
      * @param typeCheck The {@link Function} that will be used to determine if values are of type
      * {@link U}.
      */
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator$1<U>;
-    static whereInstanceOf<T, U extends T>(iterator: AsyncIterator$1<T>, typeCheck: (value: T) => value is U): AsyncIterator$1<U>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator<U>;
+    static whereInstanceOf<T, U extends T>(iterator: AsyncIterator<T>, typeCheck: (value: T) => value is U): AsyncIterator<U>;
     /**
      * Get an {@link AsyncIterator} that will filter this {@link AsyncIterator} to only the values that are
      * instances of the provided {@link Type}.
      * @param type The type of values to return from the new {@link AsyncIterator}.
      */
-    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator$1<U>;
-    static whereInstanceOfType<T, U extends T>(iterator: AsyncIterator$1<T>, type: Type<U>): AsyncIterator$1<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator<U>;
+    static whereInstanceOfType<T, U extends T>(iterator: AsyncIterator<T>, type: Type<U>): AsyncIterator<U>;
     /**
      * If the condition function is undefined, then this function will return the first value in
      * this {@link AsyncIterator}. If this condition function is provided, then this function will return
@@ -914,7 +217,7 @@ declare abstract class AsyncIterator$1<T> {
      * the first value that matches the provided condition.
      * @param iterator The {@link AsyncIterator} to get the first value from.
      */
-    static first<T>(iterator: AsyncIterator$1<T>, condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
+    static first<T>(iterator: AsyncIterator<T>, condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
     /**
      * If the condition function is undefined, then this function will return the last value in this
      * {@link AsyncIterator}. If this condition function is provided, then this function will return the
@@ -928,26 +231,26 @@ declare abstract class AsyncIterator$1<T> {
      * last value that matches the provided condition.
      * @param iterator The {@link AsyncIterator} to get the last value from.
      */
-    static last<T>(iterator: AsyncIterator$1<T>, condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
+    static last<T>(iterator: AsyncIterator<T>, condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
     /**
      * Find the maximum value in the provided {@link AsyncIterator}.
      * @param iterator The values to find the maximum of.
      */
-    static findMaximum<T extends Comparable<T>>(iterator: JavascriptAsyncIterator<T> | AsyncIterator$1<T>): PromiseAsyncResult<T>;
+    static findMaximum<T extends Comparable<T>>(iterator: JavascriptAsyncIterator<T> | AsyncIterator<T>): PromiseAsyncResult<T>;
     /**
      * Get a new {@link AsyncIterator} that wraps around this {@link AsyncIterator} and only
      * returns a maximum number of values from this {@link AsyncIterator}.
      * @param maximumToTake The maximum number of values to take from this {@link AsyncIterator}.
      */
-    take(maximumToTake: number): AsyncIterator$1<T>;
-    static take<T>(iterator: AsyncIterator$1<T>, maximumToTake: number): AsyncIterator$1<T>;
+    take(maximumToTake: number): AsyncIterator<T>;
+    static take<T>(iterator: AsyncIterator<T>, maximumToTake: number): AsyncIterator<T>;
     /**
      * Get a new {@link AsyncIterator} that wraps around this {@link AsyncIterator} and will skip the initial
      * provided number of values before beginning to return values.
      * @param maximumToSkip The maximum number of values to skip from this {@link AsyncIterator}.
      */
-    skip(maximumToSkip: number): AsyncIterator$1<T>;
-    static skip<T>(iterator: AsyncIterator$1<T>, maximumToSkip: number): AsyncIterator$1<T>;
+    skip(maximumToSkip: number): AsyncIterator<T>;
+    static skip<T>(iterator: AsyncIterator<T>, maximumToSkip: number): AsyncIterator<T>;
 }
 
 /**
@@ -957,7 +260,7 @@ declare class AsyncIteratorToJavascriptAsyncIteratorAdapter<T> implements Javasc
     private readonly iterator;
     private hasStarted;
     private constructor();
-    static create<T>(iterator: AsyncIterator$1<T>): AsyncIteratorToJavascriptAsyncIteratorAdapter<T>;
+    static create<T>(iterator: AsyncIterator<T>): AsyncIteratorToJavascriptAsyncIteratorAdapter<T>;
     next(): Promise<JavascriptIteratorResult<T>>;
 }
 
@@ -1003,7 +306,7 @@ declare class SyncDisposable implements Disposable {
     isDisposed(): boolean;
 }
 
-declare abstract class List<T> implements Iterable$1<T> {
+declare abstract class List<T> implements Indexable<T> {
     static create<T>(values?: JavascriptIterable<T>): List<T>;
     /**
      * Add the provided value to the end of this {@link List}.
@@ -1069,7 +372,7 @@ declare abstract class List<T> implements Iterable$1<T> {
     removeLast(): SyncResult<T>;
     static removeLast<T, TList extends List<T>>(list: TList): SyncResult<T>;
     abstract set(index: number, value: T): this;
-    abstract iterate(): Iterator$1<T>;
+    abstract iterate(): Iterator<T>;
     abstract get(index: number): SyncResult<T>;
     toArray(): SyncResult<T[]>;
     static toArray<T>(list: List<T>): SyncResult<T[]>;
@@ -1081,16 +384,16 @@ declare abstract class List<T> implements Iterable$1<T> {
     static equals<T>(left: List<T>, right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
     static toString<T>(list: List<T>, toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    static concatenate<T>(list: List<T>, ...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    static map<TInput, TOutput>(list: List<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    static flatMap<TInput, TOutput>(list: List<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    static where<T>(list: List<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable$1<TOutput>;
-    static instanceOf<TInput, TOutput extends TInput>(list: List<TInput>, typeOrTypeCheck: Type<TOutput> | ((value: TInput) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    static concatenate<T>(list: List<T>, ...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    static map<TInput, TOutput>(list: List<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    static flatMap<TInput, TOutput>(list: List<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    static where<T>(list: List<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>;
+    static instanceOf<TInput, TOutput extends TInput>(list: List<TInput>, typeOrTypeCheck: Type<TOutput> | ((value: TInput) => value is TOutput)): Iterable<TOutput>;
     first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     static first<T>(list: List<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
     last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
@@ -1118,18 +421,18 @@ declare class ByteList implements List<number> {
     removeFirst(): SyncResult<number>;
     removeLast(): SyncResult<number>;
     set(index: number, value: number): this;
-    iterate(): Iterator$1<number>;
+    iterate(): Iterator<number>;
     get(index: number): SyncResult<number>;
     toArray(): SyncResult<number[]>;
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     equals(right: JavascriptIterable<number>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<number>[]): Iterable$1<number>;
-    map<TOutput>(mapping: (value: number) => TOutput | SyncResult<TOutput>): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: number) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: number) => (boolean | SyncResult<boolean>)): Iterable$1<number>;
-    instanceOf<TOutput extends number>(typeOrTypeCheck: Type<TOutput> | ((value: number) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<number>[]): Iterable<number>;
+    map<TOutput>(mapping: (value: number) => TOutput | SyncResult<TOutput>): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: number) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: number) => (boolean | SyncResult<boolean>)): Iterable<number>;
+    instanceOf<TOutput extends number>(typeOrTypeCheck: Type<TOutput> | ((value: number) => value is TOutput)): Iterable<TOutput>;
     first(condition?: ((value: number) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<number>;
     last(condition?: ((value: number) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<number>;
     contains(value: number, equalFunctions?: EqualFunctions): SyncResult<boolean>;
@@ -1217,7 +520,7 @@ declare class CharacterList implements List<string> {
     insert(index: number, value: string): this;
     removeAt(index: number): SyncResult<string>;
     set(index: number, value: string): this;
-    iterate(): Iterator$1<string>;
+    iterate(): Iterator<string>;
     get(index: number): SyncResult<string>;
     add(value: string): this;
     addAll(values: JavascriptIterable<string>): this;
@@ -1229,11 +532,11 @@ declare class CharacterList implements List<string> {
     any(): SyncResult<boolean>;
     equals(right: JavascriptIterable<string>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<string>[]): Iterable$1<string>;
-    map<TOutput>(mapping: (value: string) => TOutput | SyncResult<TOutput>): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: string) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: string) => (boolean | SyncResult<boolean>)): Iterable$1<string>;
-    instanceOf<TOutput extends string>(typeOrTypeCheck: Type<TOutput> | ((value: string) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<string>[]): Iterable<string>;
+    map<TOutput>(mapping: (value: string) => TOutput | SyncResult<TOutput>): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: string) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: string) => (boolean | SyncResult<boolean>)): Iterable<string>;
+    instanceOf<TOutput extends string>(typeOrTypeCheck: Type<TOutput> | ((value: string) => value is TOutput)): Iterable<TOutput>;
     first(condition?: (value: string) => (boolean | SyncResult<boolean>)): SyncResult<string>;
     last(condition?: (value: string) => (boolean | SyncResult<boolean>)): SyncResult<string>;
     contains(value: string, equalFunctions?: EqualFunctions): SyncResult<boolean>;
@@ -1264,23 +567,6 @@ declare abstract class CharacterReadStream {
     static readLine(readStream: CharacterReadStream): AsyncResult<string>;
 }
 
-declare abstract class CharacterWriteStream {
-    /**
-     * Write the provided text to this {@link CharacterWriteStream}.
-     * @param text The text to write.
-     * @returns The number of characters that were written.
-     */
-    abstract writeString(text: string): AsyncResult<number>;
-    /**
-     * Write the provided text (if provided) and then write a newline character sequence to this
-     * {@link CharacterWriteStream}.
-     * @param text The optional text to write before the newline character sequence.
-     * @returns The number of characters that were written.
-     */
-    writeLine(text?: string): AsyncResult<number>;
-    static writeLine(writeStream: CharacterWriteStream, text?: string): AsyncResult<number>;
-}
-
 /**
  * A {@link CharacterReadStream} and {@link CharacterWriteStream} implementation that is implemented using a
  * {@link CharacterList}.
@@ -1303,7 +589,7 @@ declare class CharacterListStream implements CharacterReadStream, CharacterWrite
     readLine(): AsyncResult<string>;
 }
 
-declare class CharacterReadStreamAsyncIterator implements AsyncIterator$1<string> {
+declare class CharacterReadStreamAsyncIterator implements AsyncIterator<string> {
     private readonly readStream;
     private current;
     private started;
@@ -1318,55 +604,61 @@ declare class CharacterReadStreamAsyncIterator implements AsyncIterator$1<string
     any(): PromiseAsyncResult<boolean>;
     getCount(): PromiseAsyncResult<number>;
     toArray(): PromiseAsyncResult<string[]>;
-    where(condition: (value: string) => boolean | PromiseLike<boolean>): AsyncIterator$1<string>;
-    map<TOutput>(mapping: (value: string) => (TOutput | PromiseLike<TOutput>)): AsyncIterator$1<TOutput>;
-    whereInstanceOf<U extends string>(typeCheck: (value: string) => value is U): AsyncIterator$1<U>;
-    whereInstanceOfType<U extends string>(type: Type<U>): AsyncIterator$1<U>;
+    where(condition: (value: string) => boolean | PromiseLike<boolean>): AsyncIterator<string>;
+    map<TOutput>(mapping: (value: string) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>;
+    whereInstanceOf<U extends string>(typeCheck: (value: string) => value is U): AsyncIterator<U>;
+    whereInstanceOfType<U extends string>(type: Type<U>): AsyncIterator<U>;
     first(condition?: (value: string) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<string>;
     last(condition?: (value: string) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<string>;
-    take(maximumToTake: number): AsyncIterator$1<string>;
-    skip(maximumToSkip: number): AsyncIterator$1<string>;
+    take(maximumToTake: number): AsyncIterator<string>;
+    skip(maximumToSkip: number): AsyncIterator<string>;
     [Symbol.asyncIterator](): JavascriptAsyncIterator<string>;
 }
 
 /**
- * An individual parameter from a {@link CommandLineParameters} object.
+ * A class that can be used to define and interact with an application's command line interface.
  */
-declare class CommandLineParameter<T> {
-    /**
-     * The full name of this {@link CommandLineParameter}.
-     */
-    private readonly name;
-    /**
-     * The description for this {@link CommandLineParameter}.
-     */
-    private readonly description;
-    /**
-     * The function that can be invoked to get this {@link CommandLineParameter}'s value.
-     */
-    private readonly valueGetter;
+declare class CommandLineParameters {
+    private readonly args;
+    private readonly parameters;
     private constructor();
+    static create(args: JavascriptIterable<string>): CommandLineParameters;
+    static getArgumentName(arg: string): string | undefined;
+    getArguments(): Iterable<string>;
     /**
-     * Create a new {@link CommandLineParameter}.
-     * @param name The full name of the {@link CommandLineParameter}.
-     * @param description The description for the {@link CommandLineParameter}.
-     * @param valueGetter The function that will be used to get the returned
-     * {@link CommandLineParameter}'s value.
-     */
-    static create<T>(name: string, description: string, valueGetter: () => T): CommandLineParameter<T>;
-    /**
-     * Get the value for this {@link CommandLineParameter}.
+     * Get the value of the first argument that matches one of the provided names.
+     * @param names The possible names to look for.
      */
-    getValue(): T;
+    getNamedArgumentStringValue(nameOrNames: string | JavascriptIterable<string>): SyncResult<string>;
+    nameOrAliasExists(nameOrAlias: string): boolean;
+    add(name: string): CommandLineParameter<string>;
 }
 
 /**
- * A class that can be used to define and interact with an application's command line interface.
+ * An individual parameter from a {@link CommandLineParameters} object.
  */
-declare class CommandLineParameters {
-    private readonly args;
+declare class CommandLineParameter<T> {
+    private readonly owner;
+    private readonly name;
+    private aliases;
+    private description;
     private constructor();
-    static create(args: JavascriptIterable<string>): CommandLineParameters;
+    static create<T>(owner: CommandLineParameters, name: string): CommandLineParameter<T>;
+    static create<T>(properties: {
+        owner: CommandLineParameters;
+        name: string;
+    }): CommandLineParameter<T>;
+    /**
+     * Get the name of this {@link CommandLineParameter}.
+     */
+    getName(): string;
+    getAliases(): Iterable<string>;
+    private nameOrAliasExists;
+    addAlias(alias: string): this;
+    addAliases(aliases: JavascriptIterable<string>): this;
+    getNameAndAliases(): Iterable<string>;
+    getDescription(): string;
+    setDescription(description: string): this;
 }
 
 /**
@@ -1430,28 +722,28 @@ declare abstract class Comparer<TLeft, TRight = TLeft> {
     static compareNumbers(left: number | undefined | null, right: number | undefined | null): Comparison;
 }
 
-declare class ConcatenateIterable<T> implements Iterable$1<T> {
+declare class ConcatenateIterable<T> implements Iterable<T> {
     private readonly innerIterables;
     private constructor();
-    static create<T>(innerIterable: Iterable$1<T>, ...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterable<T>;
-    iterate(): Iterator$1<T>;
+    static create<T>(innerIterable: Iterable<T>, ...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterable<T>;
+    iterate(): Iterator<T>;
     toArray(): SyncResult<T[]>;
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>;
     first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     [Symbol.iterator](): JavascriptIterator<T>;
 }
 
-declare class ConcatenateIterator<T> implements Iterator$1<T> {
+declare class ConcatenateIterator<T> implements Iterator<T> {
     private readonly innerIterators;
     private constructor();
     static create<T>(...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterator<T>;
@@ -1464,16 +756,16 @@ declare class ConcatenateIterator<T> implements Iterator$1<T> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<T[]>;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator$1<T>;
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterator$1<T>;
-    map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterator$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): Iterator$1<U>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterator<T>;
+    map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterator<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>;
     first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
-    take(maximumToTake: number): Iterator$1<T>;
-    skip(maximumToSkip: number): Iterator$1<T>;
+    take(maximumToTake: number): Iterator<T>;
+    skip(maximumToSkip: number): Iterator<T>;
     [Symbol.iterator](): JavascriptIterator<T>;
 }
 
@@ -1829,7 +1121,7 @@ declare class MutableHttpHeaders implements HttpHeaders {
     private readonly headers;
     private constructor();
     static create(headers?: JavascriptIterable<HttpHeader>): MutableHttpHeaders;
-    iterate(): Iterator$1<HttpHeader>;
+    iterate(): Iterator<HttpHeader>;
     get(headerName: string): SyncResult<HttpHeader>;
     getValue(headerName: string): SyncResult<string>;
     /**
@@ -1849,11 +1141,11 @@ declare class MutableHttpHeaders implements HttpHeaders {
     any(): SyncResult<boolean>;
     equals(right: JavascriptIterable<HttpHeader>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable$1<HttpHeader>;
-    map<TOutput>(mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: HttpHeader) => (boolean | SyncResult<boolean>)): Iterable$1<HttpHeader>;
-    instanceOf<TOutput extends HttpHeader>(typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable<HttpHeader>;
+    map<TOutput>(mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: HttpHeader) => (boolean | SyncResult<boolean>)): Iterable<HttpHeader>;
+    instanceOf<TOutput extends HttpHeader>(typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable<TOutput>;
     first(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>;
     last(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>;
     [Symbol.iterator](): JavascriptIterator<HttpHeader>;
@@ -1863,7 +1155,7 @@ declare class MutableHttpHeaders implements HttpHeaders {
 /**
  * A collection of {@link HttpHeader}s.
  */
-declare abstract class HttpHeaders implements Iterable$1<HttpHeader> {
+declare abstract class HttpHeaders implements Iterable<HttpHeader> {
     static readonly contentTypeHeaderName: string;
     static create(headers?: JavascriptIterable<HttpHeader>): MutableHttpHeaders;
     /**
@@ -1884,7 +1176,7 @@ declare abstract class HttpHeaders implements Iterable$1<HttpHeader> {
      * Get an {@link Iterator} that can be used to iterate through the {@link HttpHeader}s in this
      * collection.
      */
-    abstract iterate(): Iterator$1<HttpHeader>;
+    abstract iterate(): Iterator<HttpHeader>;
     /**
      * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
      */
@@ -1898,16 +1190,16 @@ declare abstract class HttpHeaders implements Iterable$1<HttpHeader> {
     static equals(headers: HttpHeaders, right: JavascriptIterable<HttpHeader>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
     static toString(headers: HttpHeaders, toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable$1<HttpHeader>;
-    static concatenate(headers: HttpHeaders, ...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable$1<HttpHeader>;
-    map<TOutput>(mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    static map<TOutput>(headers: HttpHeaders, mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    static flatMap<TOutput>(headers: HttpHeaders, mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: HttpHeader) => boolean): Iterable$1<HttpHeader>;
-    static where(headers: HttpHeaders, condition: (value: HttpHeader) => (boolean | SyncResult<boolean>)): Iterable$1<HttpHeader>;
-    instanceOf<TOutput extends HttpHeader>(typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable$1<TOutput>;
-    static instanceOf<TOutput extends HttpHeader>(headers: HttpHeaders, typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable<HttpHeader>;
+    static concatenate(headers: HttpHeaders, ...toConcatenate: JavascriptIterable<HttpHeader>[]): Iterable<HttpHeader>;
+    map<TOutput>(mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    static map<TOutput>(headers: HttpHeaders, mapping: (value: HttpHeader) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    static flatMap<TOutput>(headers: HttpHeaders, mapping: (value: HttpHeader) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: HttpHeader) => boolean): Iterable<HttpHeader>;
+    static where(headers: HttpHeaders, condition: (value: HttpHeader) => (boolean | SyncResult<boolean>)): Iterable<HttpHeader>;
+    instanceOf<TOutput extends HttpHeader>(typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable<TOutput>;
+    static instanceOf<TOutput extends HttpHeader>(headers: HttpHeaders, typeOrTypeCheck: Type<TOutput> | ((value: HttpHeader) => value is TOutput)): Iterable<TOutput>;
     first(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>;
     static first(headers: HttpHeaders, condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>;
     last(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>;
@@ -2188,7 +1480,7 @@ declare class CurrentProcess {
     private constructor();
     static create(): CurrentProcess;
     static run(action: (currentProcess: CurrentProcess) => void | number | Promise<void | number>): Promise<void>;
-    getArguments(): JavascriptIterable<string>;
+    getArguments(): Iterable<string>;
     setArguments(args: JavascriptIterable<string>): this;
     getParameters(): CommandLineParameters;
     getOutputWriteStream(): CharacterWriteStream;
@@ -2271,11 +1563,11 @@ declare abstract class SearchControl<TVisit, TResult> {
     abstract break(): never;
 }
 
-declare function depthFirstSearch<TVisit, TResult>(initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit, TResult>, current: TVisit) => void): Iterator$1<TResult>;
+declare function depthFirstSearch<TVisit, TResult>(initialToVisit: JavascriptIterable<TVisit>, searchAction: (searchControl: SearchControl<TVisit, TResult>, current: TVisit) => void): Iterator<TResult>;
 declare function depthFirstSearch<TVisit, TResult>(parameters: {
     initialToVisit: JavascriptIterable<TVisit>;
     searchAction: (searchControl: SearchControl<TVisit, TResult>, current: TVisit) => void;
-}): Iterator$1<TResult>;
+}): Iterator<TResult>;
 
 /**
  * An {@link Error} that is created when something is empty.
@@ -2312,35 +1604,35 @@ declare class FetchHttpClient implements HttpClient {
     static convertMethod(method: HttpMethod): string;
 }
 
-declare class FlatMapIterable<TInput, TOutput> implements Iterable$1<TOutput> {
+declare class FlatMapIterable<TInput, TOutput> implements Iterable<TOutput> {
     private readonly innerIterable;
     private readonly mapping;
     private constructor();
-    static create<TInput, TOutput>(innerIterable: Iterable$1<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): FlatMapIterable<TInput, TOutput>;
-    iterate(): Iterator$1<TOutput>;
+    static create<TInput, TOutput>(innerIterable: Iterable<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): FlatMapIterable<TInput, TOutput>;
+    iterate(): Iterator<TOutput>;
     toArray(): SyncResult<TOutput[]>;
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     equals(right: JavascriptIterable<TOutput>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterable$1<TOutput>;
-    map<TOutput2>(mapping: (value: TOutput) => TOutput2 | SyncResult<TOutput2>): Iterable$1<TOutput2>;
-    flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterable$1<TOutput2>;
-    where(condition: (value: TOutput) => (boolean | SyncResult<boolean>)): Iterable$1<TOutput>;
-    instanceOf<TOutput2 extends TOutput>(typeOrTypeCheck: Type<TOutput2> | ((value: TOutput2) => value is TOutput2)): Iterable$1<TOutput2>;
+    concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterable<TOutput>;
+    map<TOutput2>(mapping: (value: TOutput) => TOutput2 | SyncResult<TOutput2>): Iterable<TOutput2>;
+    flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterable<TOutput2>;
+    where(condition: (value: TOutput) => (boolean | SyncResult<boolean>)): Iterable<TOutput>;
+    instanceOf<TOutput2 extends TOutput>(typeOrTypeCheck: Type<TOutput2> | ((value: TOutput2) => value is TOutput2)): Iterable<TOutput2>;
     first(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>;
     last(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>;
     contains(value: TOutput, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     [Symbol.iterator](): JavascriptIterator<TOutput>;
 }
 
-declare class FlatMapIterator<TInput, TOutput> implements Iterator$1<TOutput> {
+declare class FlatMapIterator<TInput, TOutput> implements Iterator<TOutput> {
     private readonly innerIterator;
     private readonly mapping;
     private mappingIterator;
     private started;
     private constructor();
-    static create<TInput, TOutput>(innerIterator: Iterator$1<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): FlatMapIterator<TInput, TOutput>;
+    static create<TInput, TOutput>(innerIterator: Iterator<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): FlatMapIterator<TInput, TOutput>;
     next(): SyncResult<boolean>;
     hasStarted(): boolean;
     hasCurrent(): boolean;
@@ -2350,16 +1642,16 @@ declare class FlatMapIterator<TInput, TOutput> implements Iterator$1<TOutput> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<TOutput[]>;
-    concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterator$1<TOutput>;
-    where(condition: (value: TOutput) => (boolean | SyncResult<boolean>)): Iterator$1<TOutput>;
-    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterator$1<TOutput2>;
-    flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterator$1<TOutput2>;
-    whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends TOutput>(type: Type<U>): Iterator$1<U>;
+    concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterator<TOutput>;
+    where(condition: (value: TOutput) => (boolean | SyncResult<boolean>)): Iterator<TOutput>;
+    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterator<TOutput2>;
+    flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterator<TOutput2>;
+    whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends TOutput>(type: Type<U>): Iterator<U>;
     first(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>;
     last(condition?: ((value: TOutput) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<TOutput>;
-    take(maximumToTake: number): Iterator$1<TOutput>;
-    skip(maximumToSkip: number): Iterator$1<TOutput>;
+    take(maximumToTake: number): Iterator<TOutput>;
+    skip(maximumToSkip: number): Iterator<TOutput>;
     [Symbol.iterator](): JavascriptIterator<TOutput>;
 }
 
@@ -2386,7 +1678,7 @@ interface GeneratorControl<T> {
      */
     getCurrent(): T;
 }
-declare class Generator<T> implements Iterator$1<T> {
+declare class Generator<T> implements Iterator<T> {
     private readonly control;
     private readonly generatorAction;
     private started;
@@ -2401,16 +1693,16 @@ declare class Generator<T> implements Iterator$1<T> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<T[]>;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator$1<T>;
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterator$1<T>;
-    map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterator$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): Iterator$1<U>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterator<T>;
+    map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterator<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>;
     first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
-    take(maximumToTake: number): Iterator$1<T>;
-    skip(maximumToSkip: number): Iterator$1<T>;
+    take(maximumToTake: number): Iterator<T>;
+    skip(maximumToSkip: number): Iterator<T>;
     [Symbol.iterator](): JavascriptIterator<T>;
 }
 
@@ -2434,7 +1726,7 @@ declare class IteratorToJavascriptIteratorAdapter<T> implements JavascriptIterat
     private readonly iterator;
     private hasStarted;
     private constructor();
-    static create<T>(iterator: Iterator$1<T>): IteratorToJavascriptIteratorAdapter<T>;
+    static create<T>(iterator: Iterator<T>): IteratorToJavascriptIteratorAdapter<T>;
     next(): JavascriptIteratorResult<T>;
 }
 
@@ -2443,7 +1735,7 @@ declare class JavascriptArrayList<T> implements List<T> {
     private constructor();
     static create<T>(values?: JavascriptIterable<T>): JavascriptArrayList<T>;
     set(index: number, value: T): this;
-    iterate(): Iterator$1<T>;
+    iterate(): Iterator<T>;
     getCount(): SyncResult<number>;
     get(index: number): SyncResult<T>;
     insert(index: number, value: T): this;
@@ -2458,18 +1750,18 @@ declare class JavascriptArrayList<T> implements List<T> {
     any(): SyncResult<boolean>;
     equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>;
     first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     [Symbol.iterator](): JavascriptIterator<T>;
     contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
 }
 
-declare class JavascriptAsyncIteratorToAsyncIteratorAdapter<T> implements AsyncIterator$1<T> {
+declare class JavascriptAsyncIteratorToAsyncIteratorAdapter<T> implements AsyncIterator<T> {
     private readonly javascriptIterator;
     private javascriptIteratorResult?;
     private constructor();
@@ -2483,18 +1775,18 @@ declare class JavascriptAsyncIteratorToAsyncIteratorAdapter<T> implements AsyncI
     any(): PromiseAsyncResult<boolean>;
     getCount(): PromiseAsyncResult<number>;
     toArray(): PromiseAsyncResult<T[]>;
-    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator$1<TOutput>;
+    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>;
     [Symbol.asyncIterator](): JavascriptAsyncIterator<T>;
     first(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
     last(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
-    where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator$1<T>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator$1<U>;
-    take(maximumToTake: number): AsyncIterator$1<T>;
-    skip(maximumToSkip: number): AsyncIterator$1<T>;
+    where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator<T>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator<U>;
+    take(maximumToTake: number): AsyncIterator<T>;
+    skip(maximumToSkip: number): AsyncIterator<T>;
 }
 
-declare class JavascriptIteratorToIteratorAdapter<T> implements Iterator$1<T> {
+declare class JavascriptIteratorToIteratorAdapter<T> implements Iterator<T> {
     private readonly javascriptIterator;
     private javascriptIteratorResult?;
     private constructor();
@@ -2508,17 +1800,17 @@ declare class JavascriptIteratorToIteratorAdapter<T> implements Iterator$1<T> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<T[]>;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator$1<T>;
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>;
     [Symbol.iterator](): JavascriptIterator<T>;
     first(condition?: (value: T) => boolean): SyncResult<T>;
     last(): SyncResult<T>;
-    where(condition: (value: T) => boolean): Iterator$1<T>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): Iterator$1<U>;
-    take(maximumToTake: number): Iterator$1<T>;
-    skip(maximumToSkip: number): Iterator$1<T>;
+    where(condition: (value: T) => boolean): Iterator<T>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>;
+    take(maximumToTake: number): Iterator<T>;
+    skip(maximumToSkip: number): Iterator<T>;
 }
 
 /**
@@ -2529,7 +1821,7 @@ declare function isMutableMap(value: unknown): value is MutableMap<unknown, unkn
 /**
  * A type that maps {@link TKey} values to {@link TValue} values.
  */
-declare abstract class MutableMap<TKey, TValue> implements Map$1<TKey, TValue> {
+declare abstract class MutableMap<TKey, TValue> implements Map<TKey, TValue> {
     /**
      * Create a new instance of the default {@link Map} implementation.
      */
@@ -2537,13 +1829,13 @@ declare abstract class MutableMap<TKey, TValue> implements Map$1<TKey, TValue> {
     /**
      * Iterate over the entries in this {@link MutableMap}.
      */
-    abstract iterate(): Iterator$1<MapEntry<TKey, TValue>>;
+    abstract iterate(): Iterator<MapEntry<TKey, TValue>>;
     any(): SyncResult<boolean>;
     static any<TKey, TValue>(map: MutableMap<TKey, TValue>): SyncResult<boolean>;
     toArray(): SyncResult<MapEntry<TKey, TValue>[]>;
     static toArray<TKey, TValue>(map: MutableMap<TKey, TValue>): SyncResult<MapEntry<TKey, TValue>[]>;
-    equals(right: Iterable$1<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    static equals<TKey, TValue>(left: MutableMap<TKey, TValue>, right: Iterable$1<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    equals(right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static equals<TKey, TValue>(left: MutableMap<TKey, TValue>, right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     /**
      * Get the {@link String} representation of this {@link MutableMap}.
      */
@@ -2552,16 +1844,16 @@ declare abstract class MutableMap<TKey, TValue> implements Map$1<TKey, TValue> {
      * Get the {@link String} representation of the provided {@link MutableMap}.
      */
     static toString<TKey, TValue>(map: MutableMap<TKey, TValue>, toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable$1<MapEntry<TKey, TValue>>;
-    static concatenate<TKey, TValue>(map: MutableMap<TKey, TValue>, ...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable$1<MapEntry<TKey, TValue>>;
-    map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    static map<TKey, TValue, TOutput>(map: MutableMap<TKey, TValue>, mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    static flatMap<TKey, TValue, TOutput>(map: MutableMap<TKey, TValue>, mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable$1<MapEntry<TKey, TValue>>;
-    static where<TKey, TValue>(map: MutableMap<TKey, TValue>, condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable$1<MapEntry<TKey, TValue>>;
-    instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable$1<T>;
-    static instanceOf<TKey, TValue, T extends MapEntry<TKey, TValue>>(map: MutableMap<TKey, TValue>, typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable$1<T>;
+    concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>;
+    static concatenate<TKey, TValue>(map: MutableMap<TKey, TValue>, ...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>;
+    map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    static map<TKey, TValue, TOutput>(map: MutableMap<TKey, TValue>, mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    static flatMap<TKey, TValue, TOutput>(map: MutableMap<TKey, TValue>, mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey, TValue>>;
+    static where<TKey, TValue>(map: MutableMap<TKey, TValue>, condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey, TValue>>;
+    instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>;
+    static instanceOf<TKey, TValue, T extends MapEntry<TKey, TValue>>(map: MutableMap<TKey, TValue>, typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>;
     [Symbol.iterator](): JavascriptIterator<MapEntry<TKey, TValue>>;
     static [Symbol.iterator]<TKey, TValue>(map: MutableMap<TKey, TValue>): JavascriptIterator<MapEntry<TKey, TValue>>;
     /**
@@ -2619,21 +1911,21 @@ declare abstract class MutableMap<TKey, TValue> implements Map$1<TKey, TValue> {
     /**
      * Iterate over the keys in this {@link MutableMap}.
      */
-    iterateKeys(): Iterator$1<TKey>;
+    iterateKeys(): Iterator<TKey>;
     /**
      * Iterate over the keys in the {@link MutableMap}.
      * @param map The map to iterate over.
      */
-    static iterateKeys<TKey, TValue>(map: MutableMap<TKey, TValue>): Iterator$1<TKey>;
+    static iterateKeys<TKey, TValue>(map: MutableMap<TKey, TValue>): Iterator<TKey>;
     /**
      * Iterate over the values in this {@link MutableMap}.
      */
-    iterateValues(): Iterator$1<TValue>;
+    iterateValues(): Iterator<TValue>;
     /**
      * Iterate over the keys in the {@link MutableMap}.
      * @param map The map to iterate over.
      */
-    static iterateValues<TKey, TValue>(map: MutableMap<TKey, TValue>): Iterator$1<TValue>;
+    static iterateValues<TKey, TValue>(map: MutableMap<TKey, TValue>): Iterator<TValue>;
     contains(value: MapEntry<TKey, TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     static contains<TKey, TValue>(map: MutableMap<TKey, TValue>, value: MapEntry<TKey, TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
 }
@@ -2642,7 +1934,7 @@ declare abstract class MutableMap<TKey, TValue> implements Map$1<TKey, TValue> {
  * Get whether the provided value is {@link Map}.
  * @param value The value to check.
  */
-declare function isMap(value: unknown): value is Map$1<unknown, unknown>;
+declare function isMap(value: unknown): value is Map<unknown, unknown>;
 /**
  * An entry within a {@link Map}.
  */
@@ -2659,7 +1951,7 @@ interface MapEntry<TKey, TValue> {
 /**
  * A type that maps {@link TKey} values to {@link TValue} values.
  */
-declare abstract class Map$1<TKey, TValue> implements Iterable$1<MapEntry<TKey, TValue>> {
+declare abstract class Map<TKey, TValue> implements Iterable<MapEntry<TKey, TValue>> {
     /**
      * Create a new instance of the default {@link MutableMap} implementation.
      */
@@ -2667,13 +1959,13 @@ declare abstract class Map$1<TKey, TValue> implements Iterable$1<MapEntry<TKey,
     /**
      * Iterate over the entries in this {@link Map}.
      */
-    abstract iterate(): Iterator$1<MapEntry<TKey, TValue>>;
+    abstract iterate(): Iterator<MapEntry<TKey, TValue>>;
     any(): SyncResult<boolean>;
-    static any<TKey, TValue>(map: Map$1<TKey, TValue>): SyncResult<boolean>;
+    static any<TKey, TValue>(map: Map<TKey, TValue>): SyncResult<boolean>;
     toArray(): SyncResult<MapEntry<TKey, TValue>[]>;
-    static toArray<TKey, TValue>(map: Map$1<TKey, TValue>): SyncResult<MapEntry<TKey, TValue>[]>;
-    equals(right: Iterable$1<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    static equals<TKey, TValue>(left: Map$1<TKey, TValue>, right: Iterable$1<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static toArray<TKey, TValue>(map: Map<TKey, TValue>): SyncResult<MapEntry<TKey, TValue>[]>;
+    equals(right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static equals<TKey, TValue>(left: Map<TKey, TValue>, right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     /**
      * Get the {@link String} representation of this {@link Map}.
      */
@@ -2681,28 +1973,28 @@ declare abstract class Map$1<TKey, TValue> implements Iterable$1<MapEntry<TKey,
     /**
      * Get the {@link String} representation of the provided {@link Map}.
      */
-    static toString<TKey, TValue>(map: Map$1<TKey, TValue>, toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable$1<MapEntry<TKey, TValue>>;
-    static concatenate<TKey, TValue>(map: Map$1<TKey, TValue>, ...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable$1<MapEntry<TKey, TValue>>;
-    map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    static map<TKey, TValue, TOutput>(map: Map$1<TKey, TValue>, mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    static flatMap<TKey, TValue, TOutput>(map: Map$1<TKey, TValue>, mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable$1<MapEntry<TKey, TValue>>;
-    static where<TKey, TValue>(map: Map$1<TKey, TValue>, condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable$1<MapEntry<TKey, TValue>>;
-    instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable$1<T>;
-    static instanceOf<TKey, TValue, T extends MapEntry<TKey, TValue>>(map: Map$1<TKey, TValue>, typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable$1<T>;
+    static toString<TKey, TValue>(map: Map<TKey, TValue>, toStringFunctions?: ToStringFunctions): string;
+    concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>;
+    static concatenate<TKey, TValue>(map: Map<TKey, TValue>, ...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>;
+    map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    static map<TKey, TValue, TOutput>(map: Map<TKey, TValue>, mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    static flatMap<TKey, TValue, TOutput>(map: Map<TKey, TValue>, mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey, TValue>>;
+    static where<TKey, TValue>(map: Map<TKey, TValue>, condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey, TValue>>;
+    instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>;
+    static instanceOf<TKey, TValue, T extends MapEntry<TKey, TValue>>(map: Map<TKey, TValue>, typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>;
     [Symbol.iterator](): JavascriptIterator<MapEntry<TKey, TValue>>;
-    static [Symbol.iterator]<TKey, TValue>(map: Map$1<TKey, TValue>): JavascriptIterator<MapEntry<TKey, TValue>>;
+    static [Symbol.iterator]<TKey, TValue>(map: Map<TKey, TValue>): JavascriptIterator<MapEntry<TKey, TValue>>;
     /**
      * Get the number of entries in this {@link Map}.
      */
     getCount(): SyncResult<number>;
-    static getCount<TKey, TValue>(map: Map$1<TKey, TValue>): SyncResult<number>;
+    static getCount<TKey, TValue>(map: Map<TKey, TValue>): SyncResult<number>;
     first(condition?: (entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>;
-    static first<TKey, TValue>(map: Map$1<TKey, TValue>, condition?: (entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>;
+    static first<TKey, TValue>(map: Map<TKey, TValue>, condition?: (entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>;
     last(condition?: (entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>;
-    static last<TKey, TValue>(map: Map$1<TKey, TValue>, condition?: (entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>;
+    static last<TKey, TValue>(map: Map<TKey, TValue>, condition?: (entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>;
     /**
      * Get whether this {@link Map} contains the provided key.
      * @param key The key to look for.
@@ -2716,23 +2008,23 @@ declare abstract class Map$1<TKey, TValue> implements Iterable$1<MapEntry<TKey,
     /**
      * Iterate over the keys in this {@link Map}.
      */
-    iterateKeys(): Iterator$1<TKey>;
+    iterateKeys(): Iterator<TKey>;
     /**
      * Iterate over the keys in the {@link Map}.
      * @param map The map to iterate over.
      */
-    static iterateKeys<TKey, TValue>(map: Map$1<TKey, TValue>): Iterator$1<TKey>;
+    static iterateKeys<TKey, TValue>(map: Map<TKey, TValue>): Iterator<TKey>;
     /**
      * Iterate over the values in this {@link Map}.
      */
-    iterateValues(): Iterator$1<TValue>;
+    iterateValues(): Iterator<TValue>;
     /**
      * Iterate over the keys in the {@link Map}.
      * @param map The map to iterate over.
      */
-    static iterateValues<TKey, TValue>(map: Map$1<TKey, TValue>): Iterator$1<TValue>;
+    static iterateValues<TKey, TValue>(map: Map<TKey, TValue>): Iterator<TValue>;
     contains(value: MapEntry<TKey, TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    static contains<TKey, TValue>(map: Map$1<TKey, TValue>, value: MapEntry<TKey, TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static contains<TKey, TValue>(map: Map<TKey, TValue>, value: MapEntry<TKey, TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
 }
 
 declare class JavascriptMapMap<TKey, TValue> implements MutableMap<TKey, TValue> {
@@ -2745,17 +2037,17 @@ declare class JavascriptMapMap<TKey, TValue> implements MutableMap<TKey, TValue>
     get(key: TKey): SyncResult<TValue>;
     set(key: TKey, value: TValue): this;
     remove(key: TKey): SyncResult<TValue>;
-    iterate(): Iterator$1<MapEntry<TKey, TValue>>;
-    iterateKeys(): Iterator$1<TKey>;
-    iterateValues(): Iterator$1<TValue>;
+    iterate(): Iterator<MapEntry<TKey, TValue>>;
+    iterateKeys(): Iterator<TKey>;
+    iterateValues(): Iterator<TValue>;
     toArray(): SyncResult<MapEntry<TKey, TValue>[]>;
-    equals(right: Iterable$1<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    equals(right: Iterable<MapEntry<TKey, TValue>>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable$1<MapEntry<TKey, TValue>>;
-    map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable$1<MapEntry<TKey, TValue>>;
-    instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable$1<T>;
+    concatenate(...toConcatenate: JavascriptIterable<MapEntry<TKey, TValue>>[]): Iterable<MapEntry<TKey, TValue>>;
+    map<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: MapEntry<TKey, TValue>) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): Iterable<MapEntry<TKey, TValue>>;
+    instanceOf<T extends MapEntry<TKey, TValue>>(typeOrTypeCheck: Type<T> | ((value: MapEntry<TKey, TValue>) => value is T)): Iterable<T>;
     first(condition?: ((entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<MapEntry<TKey, TValue>>;
     last(condition?: ((entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<MapEntry<TKey, TValue>>;
     getOrSet(key: TKey, valueCreator: () => TValue | SyncResult<TValue>): SyncResult<TValue>;
@@ -2767,8 +2059,8 @@ declare class JavascriptMapMap<TKey, TValue> implements MutableMap<TKey, TValue>
  * Get whether the provided value is a {@link Set}.
  * @param value The value to check.
  */
-declare function isSet(value: unknown): value is Set$1<unknown>;
-declare abstract class Set$1<T> implements Iterable$1<T> {
+declare function isSet(value: unknown): value is Set<unknown>;
+declare abstract class Set<T> implements Iterable<T> {
     static create<T>(initialValues?: JavascriptIterable<T>): JavascriptSetSet<T>;
     /**
      * Add the provided value to this {@link Set}.
@@ -2776,66 +2068,66 @@ declare abstract class Set$1<T> implements Iterable$1<T> {
      */
     abstract add(value: T): this;
     addAll(values: JavascriptIterable<T>): this;
-    static addAll<T, TSet extends Set$1<T>>(set: TSet, values: JavascriptIterable<T>): TSet;
+    static addAll<T, TSet extends Set<T>>(set: TSet, values: JavascriptIterable<T>): TSet;
     /**
      * Remove the provided value from this {@link Set}. Return a {@link NotFoundError} if the value
      * is not found.
      * @param value The value to remove.
      */
     abstract remove(value: T): SyncResult<void>;
-    abstract iterate(): Iterator$1<T>;
-    union(values: JavascriptIterable<T>): Set$1<T>;
-    static union<T>(set: Set$1<T>, values: JavascriptIterable<T>): Set$1<T>;
+    abstract iterate(): Iterator<T>;
+    union(values: JavascriptIterable<T>): Set<T>;
+    static union<T>(set: Set<T>, values: JavascriptIterable<T>): Set<T>;
     toArray(): SyncResult<T[]>;
-    static toArray<T>(set: Set$1<T>): SyncResult<T[]>;
+    static toArray<T>(set: Set<T>): SyncResult<T[]>;
     any(): SyncResult<boolean>;
-    static any<T>(set: Set$1<T>): SyncResult<boolean>;
+    static any<T>(set: Set<T>): SyncResult<boolean>;
     getCount(): SyncResult<number>;
-    static getCount<T>(set: Set$1<T>): SyncResult<number>;
+    static getCount<T>(set: Set<T>): SyncResult<number>;
     equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    static equals<T>(left: Set$1<T>, right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    static equalSet<T>(left: Set$1<T>, right: Set$1<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static equals<T>(left: Set<T>, right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static equalSet<T>(left: Set<T>, right: Set<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    static toString<T>(set: Set$1<T>, toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    static concatenate<T>(set: Set$1<T>, ...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    static map<TInput, TOutput>(set: Set$1<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    static flatMap<TInput, TOutput>(set: Set$1<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    static where<T>(set: Set$1<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable$1<TOutput>;
-    static instanceOf<TInput, TOutput extends TInput>(set: Set$1<TInput>, typeOrTypeCheck: Type<TOutput> | ((value: TInput) => value is TOutput)): Iterable$1<TOutput>;
+    static toString<T>(set: Set<T>, toStringFunctions?: ToStringFunctions): string;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    static concatenate<T>(set: Set<T>, ...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    static map<TInput, TOutput>(set: Set<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    static flatMap<TInput, TOutput>(set: Set<TInput>, mapping: (value: TInput) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    static where<T>(set: Set<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>;
+    static instanceOf<TInput, TOutput extends TInput>(set: Set<TInput>, typeOrTypeCheck: Type<TOutput> | ((value: TInput) => value is TOutput)): Iterable<TOutput>;
     first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
-    static first<T>(set: Set$1<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
+    static first<T>(set: Set<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
     last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
-    static last<T>(set: Set$1<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
+    static last<T>(set: Set<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
     [Symbol.iterator](): JavascriptIterator<T>;
-    static [Symbol.iterator]<T>(set: Set$1<T>): JavascriptIterator<T>;
+    static [Symbol.iterator]<T>(set: Set<T>): JavascriptIterator<T>;
     contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
-    static contains<T>(set: Set$1<T>, value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static contains<T>(set: Set<T>, value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
 }
 
-declare class JavascriptSetSet<T> implements Set$1<T> {
+declare class JavascriptSetSet<T> implements Set<T> {
     private readonly set;
     private constructor();
     static create<T>(initialValues?: JavascriptIterable<T>): JavascriptSetSet<T>;
     add(value: T): this;
     addAll(values: JavascriptIterable<T>): this;
     remove(value: T): SyncResult<void>;
-    union(values: JavascriptIterable<T>): Set$1<T>;
-    iterate(): Iterator$1<T>;
+    union(values: JavascriptIterable<T>): Set<T>;
+    iterate(): Iterator<T>;
     toArray(): SyncResult<T[]>;
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    map<TOutput>(mapping: (value: T) => TOutput | SyncResult<TOutput>): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>;
     first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
@@ -2901,6 +2193,10 @@ declare abstract class Stack<T> {
      * Get whether there are any values in this {@link Stack}.
      */
     abstract any(): AsyncResult<boolean>;
+    /**
+     * Get the number of values that are currently in this {@link Stack}.
+     */
+    abstract getCount(): AsyncResult<number>;
     /**
      * Push the provided value onto the top of this {@link Stack}.
      * @param value The value to push on the top of this {@link Stack}.
@@ -2928,6 +2224,7 @@ declare class ListStack<T> implements Stack<T> {
     private constructor();
     static create<T>(list?: List<T>): ListStack<T>;
     any(): SyncResult<boolean>;
+    getCount(): SyncResult<number>;
     add(value: T): SyncResult<void>;
     addAll(values: JavascriptIterable<T>): SyncResult<void>;
     remove(): SyncResult<T>;
@@ -2961,13 +2258,13 @@ declare class LuxonDateTime implements DateTime {
 /**
  * An {@link AsyncIterator} that maps {@link TInput} values to {@link TOutput} values.
  */
-declare class MapAsyncIterator<TInput, TOutput> implements AsyncIterator$1<TOutput> {
+declare class MapAsyncIterator<TInput, TOutput> implements AsyncIterator<TOutput> {
     private readonly inputIterator;
     private readonly mapping;
     private current;
     private started;
-    protected constructor(inputIterator: AsyncIterator$1<TInput>, mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>));
-    static create<TInput, TOutput>(inputIterator: AsyncIterator$1<TInput>, mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>)): MapAsyncIterator<TInput, TOutput>;
+    protected constructor(inputIterator: AsyncIterator<TInput>, mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>));
+    static create<TInput, TOutput>(inputIterator: AsyncIterator<TInput>, mapping: (value: TInput) => (TOutput | PromiseLike<TOutput>)): MapAsyncIterator<TInput, TOutput>;
     next(): PromiseAsyncResult<boolean>;
     hasStarted(): boolean;
     hasCurrent(): boolean;
@@ -2977,34 +2274,34 @@ declare class MapAsyncIterator<TInput, TOutput> implements AsyncIterator$1<TOutp
     any(): PromiseAsyncResult<boolean>;
     getCount(): PromiseAsyncResult<number>;
     toArray(): PromiseAsyncResult<TOutput[]>;
-    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | PromiseLike<TOutput2>)): AsyncIterator$1<TOutput2>;
+    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | PromiseLike<TOutput2>)): AsyncIterator<TOutput2>;
     [Symbol.asyncIterator](): JavascriptAsyncIterator<TOutput>;
     first(condition?: (value: TOutput) => boolean): PromiseAsyncResult<TOutput>;
     last(): PromiseAsyncResult<TOutput>;
-    where(condition: (value: TOutput) => (boolean | PromiseLike<boolean>)): AsyncIterator$1<TOutput>;
-    whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): AsyncIterator$1<U>;
-    whereInstanceOfType<U extends TOutput>(type: Type<U>): AsyncIterator$1<U>;
-    take(maximumToTake: number): AsyncIterator$1<TOutput>;
-    skip(maximumToSkip: number): AsyncIterator$1<TOutput>;
+    where(condition: (value: TOutput) => (boolean | PromiseLike<boolean>)): AsyncIterator<TOutput>;
+    whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): AsyncIterator<U>;
+    whereInstanceOfType<U extends TOutput>(type: Type<U>): AsyncIterator<U>;
+    take(maximumToTake: number): AsyncIterator<TOutput>;
+    skip(maximumToSkip: number): AsyncIterator<TOutput>;
 }
 
 /**
  * An {@link Iterable} that converts {@link TInput} values to {@link TOutput} values.
  */
-declare class MapIterable<TInput, TOutput> implements Iterable$1<TOutput> {
+declare class MapIterable<TInput, TOutput> implements Iterable<TOutput> {
     private readonly innerIterable;
     private readonly mapping;
-    protected constructor(innerIterable: Iterable$1<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>));
-    static create<TInput, TOutput>(innerIterable: Iterable$1<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): MapIterable<TInput, TOutput>;
-    iterate(): Iterator$1<TOutput>;
+    protected constructor(innerIterable: Iterable<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>));
+    static create<TInput, TOutput>(innerIterable: Iterable<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): MapIterable<TInput, TOutput>;
+    iterate(): Iterator<TOutput>;
     toArray(): SyncResult<TOutput[]>;
-    equals(right: Iterable$1<TOutput>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    equals(right: Iterable<TOutput>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(): string;
-    concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterable$1<TOutput>;
-    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterable$1<TOutput2>;
-    flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterable$1<TOutput2>;
-    where(condition: (value: TOutput) => boolean): Iterable$1<TOutput>;
-    instanceOf<TOutput2 extends TOutput>(typeOrTypeCheck: Type<TOutput2> | ((value: TOutput) => value is TOutput2)): Iterable$1<TOutput2>;
+    concatenate(...toConcatenate: JavascriptIterable<TOutput>[]): Iterable<TOutput>;
+    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterable<TOutput2>;
+    flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterable<TOutput2>;
+    where(condition: (value: TOutput) => boolean): Iterable<TOutput>;
+    instanceOf<TOutput2 extends TOutput>(typeOrTypeCheck: Type<TOutput2> | ((value: TOutput) => value is TOutput2)): Iterable<TOutput2>;
     [Symbol.iterator](): JavascriptIterator<TOutput>;
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
@@ -3016,12 +2313,12 @@ declare class MapIterable<TInput, TOutput> implements Iterable$1<TOutput> {
 /**
  * An {@link Iterator} that maps {@link TInput} values to {@link TOutput} values.
  */
-declare class MapIterator<TInput, TOutput> implements Iterator$1<TOutput> {
+declare class MapIterator<TInput, TOutput> implements Iterator<TOutput> {
     private readonly inputIterator;
     private readonly mapping;
     private started;
-    protected constructor(inputIterator: Iterator$1<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>));
-    static create<TInput, TOutput>(inputIterator: Iterator$1<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): MapIterator<TInput, TOutput>;
+    protected constructor(inputIterator: Iterator<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>));
+    static create<TInput, TOutput>(inputIterator: Iterator<TInput>, mapping: (value: TInput) => (TOutput | SyncResult<TOutput>)): MapIterator<TInput, TOutput>;
     next(): SyncResult<boolean>;
     hasStarted(): boolean;
     hasCurrent(): boolean;
@@ -3031,17 +2328,17 @@ declare class MapIterator<TInput, TOutput> implements Iterator$1<TOutput> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<TOutput[]>;
-    concatenate(toConcatenate: JavascriptIterable<TOutput>): Iterator$1<TOutput>;
-    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterator$1<TOutput2>;
-    flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterator$1<TOutput2>;
+    concatenate(toConcatenate: JavascriptIterable<TOutput>): Iterator<TOutput>;
+    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | SyncResult<TOutput2>)): Iterator<TOutput2>;
+    flatMap<TOutput2>(mapping: (value: TOutput) => JavascriptIterable<TOutput2>): Iterator<TOutput2>;
     [Symbol.iterator](): JavascriptIterator<TOutput>;
     first(condition?: (value: TOutput) => boolean): SyncResult<TOutput>;
     last(): SyncResult<TOutput>;
-    where(condition: (value: TOutput) => boolean): Iterator$1<TOutput>;
-    whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends TOutput>(type: Type<U>): Iterator$1<U>;
-    take(maximumToTake: number): Iterator$1<TOutput>;
-    skip(maximumToSkip: number): Iterator$1<TOutput>;
+    where(condition: (value: TOutput) => boolean): Iterator<TOutput>;
+    whereInstanceOf<U extends TOutput>(typeCheck: (value: TOutput) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends TOutput>(type: Type<U>): Iterator<U>;
+    take(maximumToTake: number): Iterator<TOutput>;
+    skip(maximumToSkip: number): Iterator<TOutput>;
 }
 
 declare class Node<T> {
@@ -3050,7 +2347,7 @@ declare class Node<T> {
     private constructor();
     static create<T>(value: T): Node<T>;
     getValue(): T;
-    iterateConnectedNodes(): Iterator$1<Node<T>>;
+    iterateConnectedNodes(): Iterator<Node<T>>;
     addConnectedNode(node: Node<T>): void;
 }
 
@@ -3527,7 +2824,7 @@ declare class RecreationDotGovDivisionAvailability {
     readonly json: RecreationDotGovDivisionAvailabilityJson;
     readonly minimumGroupSize?: number;
     readonly maximumGroupSize?: number;
-    readonly dayAvailabilities: Iterable$1<RecreationDotGovDivisionDayAvailability>;
+    readonly dayAvailabilities: Iterable<RecreationDotGovDivisionDayAvailability>;
     private constructor();
     static create(json: RecreationDotGovDivisionAvailabilityJson): RecreationDotGovDivisionAvailability;
 }
@@ -3564,12 +2861,12 @@ declare class RecreationDotGovClient implements HttpClient {
  * An {@link AsyncIterator} that skips the first maximum number of values from an inner
  * {@link AsyncIterator} before beginning to return values.
  */
-declare class SkipAsyncIterator<T> implements AsyncIterator$1<T> {
+declare class SkipAsyncIterator<T> implements AsyncIterator<T> {
     private readonly innerIterator;
     private started;
     private readonly maximumToSkip;
     private constructor();
-    static create<T>(innerIterator: AsyncIterator$1<T>, maximumToSkip: number): SkipAsyncIterator<T>;
+    static create<T>(innerIterator: AsyncIterator<T>, maximumToSkip: number): SkipAsyncIterator<T>;
     next(): PromiseAsyncResult<boolean>;
     hasStarted(): boolean;
     hasCurrent(): boolean;
@@ -3579,27 +2876,27 @@ declare class SkipAsyncIterator<T> implements AsyncIterator$1<T> {
     any(): PromiseAsyncResult<boolean>;
     getCount(): PromiseAsyncResult<number>;
     toArray(): PromiseAsyncResult<T[]>;
-    where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator$1<T>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator$1<U>;
-    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator$1<TOutput>;
+    where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator<T>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator<U>;
+    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>;
     first(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
     last(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
     [Symbol.asyncIterator](): JavascriptAsyncIterator<T>;
-    take(maximumToTake: number): AsyncIterator$1<T>;
-    skip(maximumToSkip: number): AsyncIterator$1<T>;
+    take(maximumToTake: number): AsyncIterator<T>;
+    skip(maximumToSkip: number): AsyncIterator<T>;
 }
 
 /**
  * An {@link Iterator} that skips the first maximum number of values from an inner {@link Iterator}
  * before beginning to return values.
  */
-declare class SkipIterator<T> implements Iterator$1<T> {
+declare class SkipIterator<T> implements Iterator<T> {
     private readonly innerIterator;
     private started;
     private readonly maximumToSkip;
     private constructor();
-    static create<T>(innerIterator: Iterator$1<T>, maximumToSkip: number): SkipIterator<T>;
+    static create<T>(innerIterator: Iterator<T>, maximumToSkip: number): SkipIterator<T>;
     next(): SyncResult<boolean>;
     hasStarted(): boolean;
     hasCurrent(): boolean;
@@ -3609,17 +2906,17 @@ declare class SkipIterator<T> implements Iterator$1<T> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<T[]>;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator$1<T>;
-    where(condition: (value: T) => boolean): Iterator$1<T>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): Iterator$1<U>;
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>;
+    where(condition: (value: T) => boolean): Iterator<T>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>;
     first(condition?: (value: T) => boolean): SyncResult<T>;
     last(condition?: (value: T) => boolean): SyncResult<T>;
     [Symbol.iterator](): JavascriptIterator<T>;
-    take(maximumToTake: number): Iterator$1<T>;
-    skip(maximumToSkip: number): Iterator$1<T>;
+    take(maximumToTake: number): Iterator<T>;
+    skip(maximumToSkip: number): Iterator<T>;
 }
 
 /**
@@ -3635,7 +2932,7 @@ declare class StringComparer extends Comparer<string> {
 /**
  * An {@link Iterator} that iterates over the characters in a {@link string}.
  */
-declare class StringIterator implements Iterator$1<string> {
+declare class StringIterator implements Iterator<string> {
     private readonly value;
     private currentIndex;
     private started;
@@ -3651,16 +2948,16 @@ declare class StringIterator implements Iterator$1<string> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<string[]>;
-    concatenate(...toConcatenate: JavascriptIterable<string>[]): Iterator$1<string>;
-    map<TOutput>(mapping: (value: string) => (TOutput | SyncResult<TOutput>)): Iterator$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: string) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<string>[]): Iterator<string>;
+    map<TOutput>(mapping: (value: string) => (TOutput | SyncResult<TOutput>)): Iterator<TOutput>;
+    flatMap<TOutput>(mapping: (value: string) => JavascriptIterable<TOutput>): Iterator<TOutput>;
     first(): SyncResult<string>;
     last(): SyncResult<string>;
-    where(condition: (value: string) => boolean): Iterator$1<string>;
-    whereInstanceOf<U extends string>(typeCheck: (value: string) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends string>(type: Type<U>): Iterator$1<U>;
-    take(maximumToTake: number): Iterator$1<string>;
-    skip(maximumToSkip: number): Iterator$1<string>;
+    where(condition: (value: string) => boolean): Iterator<string>;
+    whereInstanceOf<U extends string>(typeCheck: (value: string) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends string>(type: Type<U>): Iterator<U>;
+    take(maximumToTake: number): Iterator<string>;
+    skip(maximumToSkip: number): Iterator<string>;
     [Symbol.iterator](): JavascriptIterator<string>;
 }
 
@@ -3744,13 +3041,13 @@ declare function isLetterOrDigit(value: string): boolean;
 /**
  * An {@link AsyncIterator} that iterates over a maximum number of values.
  */
-declare class TakeAsyncIterator<T> implements AsyncIterator$1<T> {
+declare class TakeAsyncIterator<T> implements AsyncIterator<T> {
     private readonly innerIterator;
     private started;
     private readonly maximumToTake;
     private taken;
     private constructor();
-    static create<T>(innerIterator: AsyncIterator$1<T>, maximumToTake: number): TakeAsyncIterator<T>;
+    static create<T>(innerIterator: AsyncIterator<T>, maximumToTake: number): TakeAsyncIterator<T>;
     hasCurrent(): boolean;
     next(): PromiseAsyncResult<boolean>;
     hasStarted(): boolean;
@@ -3760,27 +3057,27 @@ declare class TakeAsyncIterator<T> implements AsyncIterator$1<T> {
     any(): PromiseAsyncResult<boolean>;
     getCount(): PromiseAsyncResult<number>;
     toArray(): PromiseAsyncResult<T[]>;
-    where(condition: (value: T) => boolean): AsyncIterator$1<T>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator$1<U>;
-    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator$1<TOutput>;
+    where(condition: (value: T) => boolean): AsyncIterator<T>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator<U>;
+    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>;
     first(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
     last(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
     [Symbol.asyncIterator](): JavascriptAsyncIterator<T>;
-    take(maximumToTake: number): AsyncIterator$1<T>;
-    skip(maximumToSkip: number): AsyncIterator$1<T>;
+    take(maximumToTake: number): AsyncIterator<T>;
+    skip(maximumToSkip: number): AsyncIterator<T>;
 }
 
 /**
  * An {@link Iterator} that iterates over a maximum number of values.
  */
-declare class TakeIterator<T> implements Iterator$1<T> {
+declare class TakeIterator<T> implements Iterator<T> {
     private readonly innerIterator;
     private started;
     private readonly maximumToTake;
     private taken;
     private constructor();
-    static create<T>(innerIterator: Iterator$1<T>, maximumToTake: number): TakeIterator<T>;
+    static create<T>(innerIterator: Iterator<T>, maximumToTake: number): TakeIterator<T>;
     hasCurrent(): boolean;
     next(): SyncResult<boolean>;
     hasStarted(): boolean;
@@ -3790,23 +3087,23 @@ declare class TakeIterator<T> implements Iterator$1<T> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<T[]>;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator$1<T>;
-    where(condition: (value: T) => boolean): Iterator$1<T>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): Iterator$1<U>;
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>;
+    where(condition: (value: T) => boolean): Iterator<T>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>;
     first(condition?: (value: T) => boolean): SyncResult<T>;
     last(condition?: (value: T) => boolean): SyncResult<T>;
     [Symbol.iterator](): JavascriptIterator<T>;
-    take(maximumToTake: number): Iterator$1<T>;
-    skip(maximumToSkip: number): Iterator$1<T>;
+    take(maximumToTake: number): Iterator<T>;
+    skip(maximumToSkip: number): Iterator<T>;
 }
 
 /**
  * An {@link Iterator} that only returns values that match a condition.
  */
-declare class WhereAsyncIterator<T> implements AsyncIterator$1<T> {
+declare class WhereAsyncIterator<T> implements AsyncIterator<T> {
     private readonly innerIterator;
     private started;
     private readonly condition;
@@ -3814,43 +3111,43 @@ declare class WhereAsyncIterator<T> implements AsyncIterator$1<T> {
     hasStarted(): boolean;
     hasCurrent(): boolean;
     getCurrent(): T;
-    static create<T>(innerIterator: AsyncIterator$1<T>, condition: (value: T) => (boolean | PromiseLike<boolean>)): WhereAsyncIterator<T>;
+    static create<T>(innerIterator: AsyncIterator<T>, condition: (value: T) => (boolean | PromiseLike<boolean>)): WhereAsyncIterator<T>;
     next(): PromiseAsyncResult<boolean>;
     start(): PromiseAsyncResult<this>;
     takeCurrent(): PromiseAsyncResult<T>;
     any(): PromiseAsyncResult<boolean>;
     getCount(): PromiseAsyncResult<number>;
     toArray(): PromiseAsyncResult<T[]>;
-    where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator$1<T>;
-    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator$1<TOutput>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator$1<U>;
+    where(condition: (value: T) => (boolean | PromiseLike<boolean>)): AsyncIterator<T>;
+    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator<TOutput>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): AsyncIterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): AsyncIterator<U>;
     first(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
     last(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
-    take(maximumToTake: number): AsyncIterator$1<T>;
-    skip(maximumToSkip: number): AsyncIterator$1<T>;
+    take(maximumToTake: number): AsyncIterator<T>;
+    skip(maximumToSkip: number): AsyncIterator<T>;
     [Symbol.asyncIterator](): JavascriptAsyncIterator<T>;
 }
 
 /**
  * An {@link Iterable} that only returns values that match a condition.
  */
-declare class WhereIterable<T> implements Iterable$1<T> {
+declare class WhereIterable<T> implements Iterable<T> {
     private readonly innerIterable;
     private readonly condition;
     private constructor();
-    static create<T>(innerIterable: Iterable$1<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): WhereIterable<T>;
-    iterate(): Iterator$1<T>;
+    static create<T>(innerIterable: Iterable<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): WhereIterable<T>;
+    iterate(): Iterator<T>;
     toArray(): SyncResult<T[]>;
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
     toString(toStringFunctions?: ToStringFunctions): string;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable$1<T>;
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable$1<TOutput>;
-    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable$1<T>;
-    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable$1<TOutput>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterable<T>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterable<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterable<TOutput>;
+    where(condition: (value: T) => (boolean | SyncResult<boolean>)): Iterable<T>;
+    instanceOf<TOutput extends T>(typeOrTypeCheck: Type<TOutput> | ((value: T) => value is TOutput)): Iterable<TOutput>;
     first(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     last(condition?: ((value: T) => (boolean | SyncResult<boolean>)) | undefined): SyncResult<T>;
     [Symbol.iterator](): JavascriptIterator<T>;
@@ -3860,12 +3157,12 @@ declare class WhereIterable<T> implements Iterable$1<T> {
 /**
  * An {@link Iterator} that only returns values that match a condition.
  */
-declare class WhereIterator<T> implements Iterator$1<T> {
+declare class WhereIterator<T> implements Iterator<T> {
     private readonly innerIterator;
     private started;
     private readonly condition;
     private constructor();
-    static create<T>(innerIterator: Iterator$1<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): WhereIterator<T>;
+    static create<T>(innerIterator: Iterator<T>, condition: (value: T) => (boolean | SyncResult<boolean>)): WhereIterator<T>;
     hasStarted(): boolean;
     hasCurrent(): boolean;
     getCurrent(): T;
@@ -3875,16 +3172,16 @@ declare class WhereIterator<T> implements Iterator$1<T> {
     any(): SyncResult<boolean>;
     getCount(): SyncResult<number>;
     toArray(): SyncResult<T[]>;
-    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator$1<T>;
-    where(condition: (value: T) => boolean): Iterator$1<T>;
-    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator$1<TOutput>;
-    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator$1<TOutput>;
-    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator$1<U>;
-    whereInstanceOfType<U extends T>(type: Type<U>): Iterator$1<U>;
+    concatenate(...toConcatenate: JavascriptIterable<T>[]): Iterator<T>;
+    where(condition: (value: T) => boolean): Iterator<T>;
+    map<TOutput>(mapping: (value: T) => (TOutput | SyncResult<TOutput>)): Iterator<TOutput>;
+    flatMap<TOutput>(mapping: (value: T) => JavascriptIterable<TOutput>): Iterator<TOutput>;
+    whereInstanceOf<U extends T>(typeCheck: (value: T) => value is U): Iterator<U>;
+    whereInstanceOfType<U extends T>(type: Type<U>): Iterator<U>;
     first(condition?: (value: T) => boolean): SyncResult<T>;
     last(condition?: (value: T) => boolean): SyncResult<T>;
-    take(maximumToTake: number): Iterator$1<T>;
-    skip(maximumToSkip: number): Iterator$1<T>;
+    take(maximumToTake: number): Iterator<T>;
+    skip(maximumToSkip: number): Iterator<T>;
     [Symbol.iterator](): JavascriptIterator<T>;
 }
 
@@ -3927,8 +3224,8 @@ declare abstract class WonderlandTrailLocations {
     static readonly carbonRiver: WonderlandTrailLocation;
     static readonly dickCreek: WonderlandTrailLocation;
     static readonly mysticLake: WonderlandTrailLocation;
-    static getLocations(): Iterable$1<WonderlandTrailLocation>;
-    static getTrailheads(): Iterable$1<WonderlandTrailLocation>;
+    static getLocations(): Iterable<WonderlandTrailLocation>;
+    static getTrailheads(): Iterable<WonderlandTrailLocation>;
 }
 declare enum WonderlandTrailReservationType {
     Reserved = 0,
@@ -3962,10 +3259,10 @@ declare class WonderlandTrailConnection {
     readonly ascentFeet: number;
     readonly descentFeet: number;
     readonly direction: WonderlandTrailDirection;
-    readonly intermediateLocations: Iterable$1<WonderlandTrailLocation>;
+    readonly intermediateLocations: Iterable<WonderlandTrailLocation>;
     private constructor();
-    static create(startLocation: WonderlandTrailLocation, endLocation: WonderlandTrailLocation, distanceMiles: number, ascentFeet: number, descentFeet: number, direction: WonderlandTrailDirection, intermediateLocations: Iterable$1<WonderlandTrailLocation>): WonderlandTrailConnection;
-    getLocations(): Iterable$1<WonderlandTrailLocation>;
+    static create(startLocation: WonderlandTrailLocation, endLocation: WonderlandTrailLocation, distanceMiles: number, ascentFeet: number, descentFeet: number, direction: WonderlandTrailDirection, intermediateLocations: Iterable<WonderlandTrailLocation>): WonderlandTrailConnection;
+    getLocations(): Iterable<WonderlandTrailLocation>;
     private static ensureExists;
     private static ensureAllExist;
     reverseDirection(): WonderlandTrailConnection;
@@ -3979,15 +3276,15 @@ declare class WonderlandTrailConnections {
     private constructor();
     static create(addReverseConnectionDefault?: boolean): WonderlandTrailConnections;
     static createDefault(): WonderlandTrailConnections;
-    iterateConnections(startLocation?: WonderlandTrailLocation, endLocation?: WonderlandTrailLocation, direction?: WonderlandTrailDirection): Iterator$1<WonderlandTrailConnection>;
+    iterateConnections(startLocation?: WonderlandTrailLocation, endLocation?: WonderlandTrailLocation, direction?: WonderlandTrailDirection): Iterator<WonderlandTrailConnection>;
     iterateConnections(properties: {
         startLocation?: WonderlandTrailLocation;
         endLocation?: WonderlandTrailLocation;
         direction?: WonderlandTrailDirection;
-    }): Iterator$1<WonderlandTrailConnection>;
+    }): Iterator<WonderlandTrailConnection>;
     private addConnectionInner;
     addConnection(connection: WonderlandTrailConnection, addReverseConnection?: boolean): this;
-    addConnection(startLocation: WonderlandTrailLocation, endLocation: WonderlandTrailLocation, distanceMiles: number, ascentFeet: number, descentFeet: number, direction?: WonderlandTrailDirection, intermediateLocations?: Iterable$1<WonderlandTrailLocation>, addReverseConnection?: boolean): this;
+    addConnection(startLocation: WonderlandTrailLocation, endLocation: WonderlandTrailLocation, distanceMiles: number, ascentFeet: number, descentFeet: number, direction?: WonderlandTrailDirection, intermediateLocations?: Iterable<WonderlandTrailLocation>, addReverseConnection?: boolean): this;
     addConnection(properties: {
         startLocation: WonderlandTrailLocation;
         endLocation: WonderlandTrailLocation;
@@ -3995,7 +3292,7 @@ declare class WonderlandTrailConnections {
         ascentFeet: number;
         descentFeet: number;
         direction?: WonderlandTrailDirection;
-        intermediateLocations?: Iterable$1<WonderlandTrailLocation>;
+        intermediateLocations?: Iterable<WonderlandTrailLocation>;
         addReverseConnection?: boolean;
     }): this;
     containsConnection(connection: WonderlandTrailConnection): boolean;
@@ -4009,14 +3306,14 @@ declare class WonderlandTrailItinerary {
     private constructor();
     static create(startDay: DateTime): WonderlandTrailItinerary;
     clone(): WonderlandTrailItinerary;
-    getConnections(): Iterable$1<WonderlandTrailConnection>;
+    getConnections(): Iterable<WonderlandTrailConnection>;
     getEndDay(): DateTime;
     getDayCount(): number;
     getStartLocation(): SyncResult<WonderlandTrailLocation>;
-    getIntermediateLocations(): Iterable$1<WonderlandTrailLocation>;
+    getIntermediateLocations(): Iterable<WonderlandTrailLocation>;
     getEndLocation(): SyncResult<WonderlandTrailLocation>;
-    getPath(): Iterable$1<WonderlandTrailLocation>;
-    getPathStrings(includeAvailabilityTypes?: boolean): Iterable$1<string>;
+    getPath(): Iterable<WonderlandTrailLocation>;
+    getPathStrings(includeAvailabilityTypes?: boolean): Iterable<string>;
     contains(parameters: {
         location: WonderlandTrailLocation;
         checkItineraryStartLocation?: boolean;
@@ -4064,7 +3361,7 @@ declare class WonderlandTrailClient implements HttpClient {
         maximumDayDistanceMiles?: number;
         maximumItineraryDays?: number;
         campsitesToAvoid?: JavascriptIterable<WonderlandTrailLocation>;
-    }): Iterable$1<WonderlandTrailItinerary>;
+    }): Iterable<WonderlandTrailItinerary>;
     findItinerariesAsync(parameters: {
         startDay: DateTime;
         startLocation?: WonderlandTrailLocation;
@@ -4076,7 +3373,7 @@ declare class WonderlandTrailClient implements HttpClient {
         allowIndividualSites?: boolean;
         allowGroupSites?: boolean;
         campsitesToAvoid?: JavascriptIterable<WonderlandTrailLocation>;
-    }): PromiseAsyncResult<Iterable$1<WonderlandTrailItinerary>>;
+    }): PromiseAsyncResult<Iterable<WonderlandTrailItinerary>>;
 }
 
-export { type AssertMessageParameters, AsyncIterator$1 as AsyncIterator, AsyncIteratorToJavascriptAsyncIteratorAdapter, AsyncResult, ByteList, ByteListStream, ByteReadStream, ByteWriteStream, Bytes, CharacterList, CharacterListStream, CharacterReadStream, CharacterReadStreamAsyncIterator, CharacterWriteStream, CommandLineParameter, CommandLineParameters, Comparable, Comparer, Comparison, ConcatenateIterable, ConcatenateIterator, Condition, CurrentProcess, DateTime, Disposable, EmptyError, EqualFunctions, FetchHttpClient, FetchHttpIncomingResponse, FlatMapIterable, FlatMapIterator, Generator, type GeneratorControl, HttpClient, HttpHeader, HttpHeaders, HttpIncomingRequest, HttpIncomingResponse, HttpMethod, HttpOutgoingRequest, HttpOutgoingResponse, HttpServer, InMemoryCharacterWriteStream, Iterable$1 as Iterable, Iterator$1 as Iterator, IteratorToJavascriptIteratorAdapter, type JavascriptArray, JavascriptArrayList, type JavascriptAsyncIterable, type JavascriptAsyncIterator, JavascriptAsyncIteratorToAsyncIteratorAdapter, type JavascriptIterable, type JavascriptIterator, type JavascriptIteratorResult, JavascriptIteratorToIteratorAdapter, JavascriptMap, JavascriptMapMap, JavascriptSet, JavascriptSetSet, List, ListQueue, ListStack, LuxonDateTime, Map$1 as Map, MapAsyncIterator, type MapEntry, MapIterable, MapIterator, MutableCondition, MutableHttpHeaders, MutableMap, Network, Node, NodeJSCharacterWriteStream, NodeJSHttpIncomingRequest, NodeJSHttpServer, NotFoundError, PostCondition, PostConditionError, PreCondition, PreConditionError, PromiseAsyncResult, Property, Queue, RealNetwork, RecreationDotGovClient, RecreationDotGovDivisionAvailability, type RecreationDotGovDivisionAvailabilityJson, type RecreationDotGovDivisionDayAvailability, type RecreationDotGovDivisionJson, RecreationDotGovError, type RecreationDotGovErrorResponse, type RecreationDotGovPermitItineraryJson, SearchControl, Set$1 as Set, SkipAsyncIterator, SkipIterator, Stack, StringComparer, StringIterator, SyncDisposable, SyncResult, TakeAsyncIterator, TakeIterator, ToStringFunctions, type Type, WhereAsyncIterator, WhereIterable, WhereIterator, WonderlandTrailAvailability, type WonderlandTrailAvailabilityType, WonderlandTrailClient, WonderlandTrailConnection, WonderlandTrailConnections, WonderlandTrailDirection, WonderlandTrailItinerary, type WonderlandTrailLocation, WonderlandTrailLocations, WonderlandTrailReservationType, andList, as, asArray, asBoolean, asFunction, asFunctionWithParameterCount, asNull, asNumber, asObject, asObjectOrArrayOrNull, asString, depthFirstSearch, escape, escapeAndQuote, getLength, getName, getParameterCount, getPropertyNames, hasFunction, hasProperty, httpMethodToString, instanceOf, instanceOfType, isArray, isAsyncIterable, isBoolean, isDigit, isFunction, isFunctionWithParameterCount, isIterable, isJavascriptAsyncIterable, isJavascriptAsyncIterator, isJavascriptIterable, isJavascriptIterator, isLetter, isLetterOrDigit, isLowercasedLetter, isMap, isMutableMap, isNull, isNumber, isObject, isObjectOrArrayOrNull, isPromise, isPromiseLike, isSet, isString, isUndefined, isUndefinedOrNull, isUppercasedLetter, isWhitespace, isWonderlandTrailLocation, join, orList, parseHttpMethod, quote, toString };
+export { ANSIStyles, type AssertMessageParameters, AsyncIterator, AsyncIteratorToJavascriptAsyncIteratorAdapter, AsyncResult, ByteList, ByteListStream, ByteReadStream, ByteWriteStream, Bytes, CharacterList, CharacterListStream, CharacterReadStream, CharacterReadStreamAsyncIterator, CharacterTable, CharacterWriteStream, CommandLineParameter, CommandLineParameters, Comparable, Comparer, Comparison, ConcatenateIterable, ConcatenateIterator, Condition, CurrentProcess, DateTime, Disposable, EmptyError, EqualFunctions, FetchHttpClient, FetchHttpIncomingResponse, FlatMapIterable, FlatMapIterator, Generator, type GeneratorControl, HttpClient, HttpHeader, HttpHeaders, HttpIncomingRequest, HttpIncomingResponse, HttpMethod, HttpOutgoingRequest, HttpOutgoingResponse, HttpServer, InMemoryCharacterWriteStream, IndentedCharacterWriteStream, Indexable, Iterable, Iterator, IteratorToJavascriptIteratorAdapter, JavascriptArrayList, JavascriptAsyncIterable, JavascriptAsyncIterator, JavascriptAsyncIteratorToAsyncIteratorAdapter, JavascriptIterable, JavascriptIterator, JavascriptIteratorResult, JavascriptIteratorToIteratorAdapter, JavascriptMapMap, JavascriptSetSet, List, ListQueue, ListStack, LuxonDateTime, Map, MapAsyncIterator, type MapEntry, MapIterable, MapIterator, MutableCondition, MutableHttpHeaders, MutableMap, Network, Node, NodeJSCharacterWriteStream, NodeJSHttpIncomingRequest, NodeJSHttpServer, NotFoundError, PostCondition, PostConditionError, PreCondition, PreConditionError, PromiseAsyncResult, Property, Queue, RealNetwork, RecreationDotGovClient, RecreationDotGovDivisionAvailability, type RecreationDotGovDivisionAvailabilityJson, type RecreationDotGovDivisionDayAvailability, type RecreationDotGovDivisionJson, RecreationDotGovError, type RecreationDotGovErrorResponse, type RecreationDotGovPermitItineraryJson, SearchControl, Set, SkipAsyncIterator, SkipIterator, Stack, StringComparer, StringIterator, SyncDisposable, SyncResult, TakeAsyncIterator, TakeIterator, ToStringFunctions, Type, WhereAsyncIterator, WhereIterable, WhereIterator, WonderlandTrailAvailability, type WonderlandTrailAvailabilityType, WonderlandTrailClient, WonderlandTrailConnection, WonderlandTrailConnections, WonderlandTrailDirection, WonderlandTrailItinerary, type WonderlandTrailLocation, WonderlandTrailLocations, WonderlandTrailReservationType, andList, depthFirstSearch, escape, escapeAndQuote, getLength, httpMethodToString, isDigit, isLetter, isLetterOrDigit, isLowercasedLetter, isMap, isMutableMap, isSet, isUppercasedLetter, isWhitespace, isWonderlandTrailLocation, join, orList, parseHttpMethod, quote, toString };