@everyonesoftware/common 3.0.0 → 4.0.0

package/outputs/sources.d.ts

@@ -0,0 +1,4082 @@
+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;
+    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>;
+}
+/**
+ * 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>;
+}
+
+/**
+ * A collection of {@link ToStringFunction}s.
+ */
+declare class ToStringFunctions {
+    private readonly functions;
+    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;
+}
+
+/**
+ * An object that can be iterated over.
+ */
+declare abstract class Iterable$1<T> implements JavascriptIterable<T> {
+    static create<T>(values?: JavascriptIterable<T>): Iterable$1<T>;
+    /**
+     * Iterate over the values in this {@link Iterable}.
+     */
+    abstract iterate(): Iterator$1<T>;
+    [Symbol.iterator](): JavascriptIterator<T>;
+    static [Symbol.iterator]<T>(iterable: Iterable$1<T>): JavascriptIterator<T>;
+    /**
+     * Get all of the values in this {@link Iterable} in an {@link Array}.
+     */
+    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.
+     */
+    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}.
+     */
+    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.
+     */
+    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}.
+     */
+    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>;
+    contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static contains<T>(iterable: Iterable$1<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}.
+ */
+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>;
+    /**
+     * Run the provided onErrorFunction if this {@link AsyncResult} contains an error.
+     * @param onErrorFunction The function to run if an error is found.
+     */
+    abstract onError(onErrorFunction: (reason: unknown) => (void | PromiseLike<void>)): AsyncResult<T>;
+    /**
+     * 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.
+     */
+    abstract onError<TError>(errorType: Type<TError>, onErrorFunction: (reason: TError) => (void | PromiseLike<void>)): AsyncResult<T>;
+    /**
+     * 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.
+     */
+    abstract convertError(convertErrorFunction: (reason: unknown) => (unknown | PromiseLike<unknown>)): AsyncResult<T>;
+    /**
+     * 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.
+     */
+    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;
+}
+
+/**
+ * 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>;
+    /**
+     * Move to the next value in the collection. Return whether this {@link AsyncIterator} points to
+     * a value after the move.
+     */
+    abstract next(): PromiseAsyncResult<boolean>;
+    /**
+     * Get whether this {@link AsyncIterator} has started iterating over the values in the collection.
+     */
+    abstract hasStarted(): boolean;
+    /**
+     * Get whether this {@link AsyncIterator} currently points at a value in the collection.
+     */
+    abstract hasCurrent(): boolean;
+    /**
+     * Get the value that this {@link AsyncIterator} points to.
+     */
+    abstract getCurrent(): T;
+    /**
+     * Move to the first value if this {@link AsyncIterator} hasn't started yet.
+     * @returns This object for method chaining.
+     */
+    start(): PromiseAsyncResult<this>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    [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>;
+    /**
+     * Get whether this {@link AsyncIterator} contains any values.
+     * Note: This may advance the {@link AsyncIterator} to the first value if it hasn't been
+     * started yet.
+     */
+    any(): PromiseAsyncResult<boolean>;
+    /**
+     * Get whether this {@link AsyncIterator} contains any values.
+     * 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>;
+    /**
+     * Get the number of values in this {@link AsyncIterator}.
+     * Note: This will consume all of the values in this {@link AsyncIterator}.
+     */
+    getCount(): PromiseAsyncResult<number>;
+    /**
+     * 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>;
+    /**
+     * Get all of the remaining values in this {@link AsyncIterator} in a {@link T} {@link Array}.
+     */
+    toArray(): PromiseAsyncResult<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[]>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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
+     * the first value that matches the provided condition.
+     * @param condition The condition that the returned value must satisfy.
+     */
+    first(condition?: (value: T) => boolean): PromiseAsyncResult<T>;
+    /**
+     * If the condition function is undefined, then this function will return the first value in
+     * the {@link AsyncIterator}. If this condition function is provided, then this function will return
+     * 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>;
+    /**
+     * 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
+     * last value that matches the provided condition.
+     * @param condition The condition that the returned value must satisfy.
+     */
+    last(condition?: (value: T) => (boolean | PromiseLike<boolean>)): PromiseAsyncResult<T>;
+    /**
+     * If the condition function is undefined, then this function will return the last value in the
+     * {@link AsyncIterator}. If this condition function is provided, then this function will return the
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+}
+
+/**
+ * A type that adapts an {@link AsyncIterator} to match a {@link JavascriptAsyncIterator}.
+ */
+declare class AsyncIteratorToJavascriptAsyncIteratorAdapter<T> implements JavascriptAsyncIterator<T> {
+    private readonly iterator;
+    private hasStarted;
+    private constructor();
+    static create<T>(iterator: AsyncIterator$1<T>): AsyncIteratorToJavascriptAsyncIteratorAdapter<T>;
+    next(): Promise<JavascriptIteratorResult<T>>;
+}
+
+/**
+ * An object that can be disposed.
+ */
+declare abstract class Disposable {
+    /**
+     * Create a new {@link Disposable} that will invoke the provided {@link Function} when it is
+     * disposed.
+     * @param disposedFunction The function to invoke when the returned {@link Disposable} is
+     * disposed.
+     */
+    static create(disposedFunction: () => void): SyncDisposable;
+    /**
+     * Synchronously clean up any resources that this object is using. This function will return
+     * true if this invocation disposed of the object. Subsequent calls to dispose() will return
+     * false.
+     */
+    abstract dispose(): AsyncResult<boolean>;
+    /**
+     * Get whether this {@link Disposable} has been disposed yet.
+     */
+    abstract isDisposed(): boolean;
+}
+
+/**
+ * A {@link Disposable} type that can be configured with a function that will be invoked when the
+ * object is disposed.
+ */
+declare class SyncDisposable implements Disposable {
+    private readonly disposedFunction;
+    private disposed;
+    protected constructor(disposedFunction: () => void);
+    /**
+     * Create a new {@link Disposable} that will invoke the provided {@link Function} when it is
+     * disposed.
+     * @param disposedFunction The function to invoke when the returned {@link Disposable} is
+     * disposed.
+     */
+    static create(disposedFunction: () => void): SyncDisposable;
+    dispose(): SyncResult<boolean>;
+    isDisposed(): boolean;
+}
+
+declare abstract class List<T> implements Iterable$1<T> {
+    static create<T>(values?: JavascriptIterable<T>): List<T>;
+    /**
+     * Add the provided value to the end of this {@link List}.
+     * @param value The value to add.
+     */
+    add(value: T): this;
+    /**
+     * Add the provided value to the provided {@link List}.
+     * @param list The {@link List} to add the value to.
+     * @param value The value to add.
+     */
+    static add<T, TList extends List<T>>(list: TList, value: T): TList;
+    /**
+     * Add the provided values to the end of this {@link List}.
+     * @param values The values to add.
+     */
+    addAll(values: JavascriptIterable<T>): this;
+    /**
+     * Add the provided values to the end of the provided {@link List}.
+     * @param list The {@link List} to add the values to.
+     * @param values The values to add.
+     */
+    static addAll<T, TList extends List<T>>(list: TList, values: JavascriptIterable<T>): TList;
+    /**
+     * Insert the value at the index in this {@link List}.
+     * @param index The index to insert the value at.
+     * @param value The value to insert.
+     */
+    abstract insert(index: number, value: T): this;
+    /**
+     * Insert the values at the index in this {@link List}.
+     * @param index The index to insert the values at.
+     * @param values The values to insert.
+     */
+    insertAll(index: number, values: JavascriptIterable<T>): this;
+    /**
+     * Insert the values at the index in this {@link List}.
+     * @param list The list to insert the values into.
+     * @param index The index to insert the values at.
+     * @param values The values to insert.
+     */
+    static insertAll<T, TList extends List<T>>(list: TList, index: number, values: JavascriptIterable<T>): TList;
+    /**
+     * Attempt to remove the first instance of the provided value from this {@link List}. Return
+     * whether the removed value.
+     * @param value The value to remove.
+     */
+    remove(value: T, equalFunctions?: EqualFunctions): SyncResult<T>;
+    static remove<T>(list: List<T>, value: T, equalFunctions?: EqualFunctions): SyncResult<T>;
+    /**
+     * Remove and return the value in this {@link List} at the provided index.
+     * @param index The index to remove a value from.
+     */
+    abstract removeAt(index: number): SyncResult<T>;
+    /**
+     * Remove the first value in this {@link List}.
+     */
+    removeFirst(): SyncResult<T>;
+    static removeFirst<T, TList extends List<T>>(list: TList): SyncResult<T>;
+    /**
+     * Remove the last value in this {@link List}.
+     */
+    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 get(index: number): SyncResult<T>;
+    toArray(): SyncResult<T[]>;
+    static toArray<T>(list: List<T>): SyncResult<T[]>;
+    any(): SyncResult<boolean>;
+    static any<T>(list: List<T>): SyncResult<boolean>;
+    getCount(): SyncResult<number>;
+    static getCount<T>(list: List<T>): SyncResult<number>;
+    equals(right: JavascriptIterable<T>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    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>;
+    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>;
+    static last<T>(list: List<T>, condition?: (value: T) => (boolean | SyncResult<boolean>)): SyncResult<T>;
+    [Symbol.iterator](): JavascriptIterator<T>;
+    static [Symbol.iterator]<T>(list: List<T>): JavascriptIterator<T>;
+    contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static contains<T>(list: List<T>, value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+}
+
+/**
+ * A {@link List} of bytes.
+ */
+declare class ByteList implements List<number> {
+    private bytes;
+    private count;
+    private constructor();
+    static create(initialValues?: JavascriptIterable<number>): ByteList;
+    add(value: number): this;
+    addAll(values: JavascriptIterable<number>): this;
+    insert(index: number, value: number): this;
+    insertAll(index: number, values: JavascriptIterable<number>): this;
+    remove(value: number, equalFunctions?: EqualFunctions): SyncResult<number>;
+    removeAt(index: number): SyncResult<number>;
+    removeFirst(): SyncResult<number>;
+    removeLast(): SyncResult<number>;
+    set(index: number, value: number): this;
+    iterate(): Iterator$1<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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<number>;
+}
+
+/**
+ * A stream that reads bytes.
+ */
+declare abstract class ByteReadStream {
+    /**
+     * Attempt to read the provided {@link count} number of bytes. Returns the bytes that were read.
+     * The number of bytes returned may be less than the number requested.
+     * @param count The number of bytes to attempt to read.
+     */
+    abstract readBytes(count: number): AsyncResult<Uint8Array>;
+    /**
+     * Attempt to read bytes into the provided output array. Returns the number of bytes that were
+     * read.
+     * @param output The array that the read bytes will be written to.
+     * @param startIndex The index in the {@link output} array to start writting the read bytes to.
+     * Defaults to 0.
+     * @param count The maximum number of bytes to read. Defaults to the length of the output array
+     * minus the startIndex.
+     */
+    abstract readBytes(output: Uint8Array, startIndex?: number, count?: number): AsyncResult<number>;
+}
+
+/**
+ * A stream that writes bytes.
+ */
+declare abstract class ByteWriteStream {
+    /**
+     * Write the provided bytes to this {@link ByteWriteStream}.
+     * @param bytes The bytes to write.
+     * @param startIndex The index to start writing from.
+     * @param length The number of bytes to write.
+     * @returns The number of bytes that were written.
+     */
+    abstract writeBytes(bytes: Uint8Array | number[], startIndex?: number, length?: number): AsyncResult<number>;
+}
+
+/**
+ * A {@link ByteReadStream} and {@link ByteWriteStream} implementation that is implemented using a
+ * {@link ByteList}.
+ */
+declare class ByteListStream implements ByteReadStream, ByteWriteStream {
+    private readonly list;
+    private constructor();
+    static create(initialValues?: Uint8Array | number[]): ByteListStream;
+    /**
+     * Get the number of bytes that are available to be read.
+     */
+    getAvailableByteCount(): number;
+    writeBytes(bytes: Uint8Array | number[], startIndex?: number, length?: number): SyncResult<number>;
+    readBytes(count: number): SyncResult<Uint8Array>;
+    readBytes(output: Uint8Array, startIndex?: number, count?: number): SyncResult<number>;
+}
+
+/**
+ * A collection of values and functions for interacting with bytes.
+ */
+declare abstract class Bytes {
+    /**
+     * The minimum value that a byte can have.
+     */
+    static readonly minimumValue: number;
+    /**
+     * The maximum value (inclusive) that a byte can have.
+     */
+    static readonly maximumValue: number;
+    /**
+     * Get whether the provided value is within the range of a valid byte (between 0 and
+     * 255).
+     * @param value The value to check.
+     */
+    static isByte(value: number): boolean;
+}
+
+declare class CharacterList implements List<string> {
+    private characters;
+    private constructor();
+    static create(values?: JavascriptIterable<string>): CharacterList;
+    getCount(): SyncResult<number>;
+    insert(index: number, value: string): this;
+    removeAt(index: number): SyncResult<string>;
+    set(index: number, value: string): this;
+    iterate(): Iterator$1<string>;
+    get(index: number): SyncResult<string>;
+    add(value: string): this;
+    addAll(values: JavascriptIterable<string>): this;
+    insertAll(index: number, values: JavascriptIterable<string>): this;
+    remove(value: string, equalFunctions?: EqualFunctions): SyncResult<string>;
+    removeFirst(): SyncResult<string>;
+    removeLast(): SyncResult<string>;
+    toArray(): SyncResult<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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<string>;
+}
+
+declare abstract class CharacterReadStream {
+    /**
+     * Read a single character from this stream.
+     */
+    abstract readCharacter(): AsyncResult<string>;
+    readCharacters(count: number): AsyncResult<string>;
+    static readCharacters(readStream: CharacterReadStream, count: number): AsyncResult<string>;
+    /**
+     * Read characters from this stream until the provided {@link searchString} is found or the end
+     * of the stream is reached. The {@link searchString} will be included in the returned string if
+     * it is found..
+     * @param searchString The string to search for.
+     */
+    readUntil(searchString: string): AsyncResult<string>;
+    static readUntil(readStream: CharacterReadStream, searchString: string): AsyncResult<string>;
+    /**
+     * Read a sequence of characters from this stream until either a newline character ('\\n') or
+     * the end of the stream is reached. Terminating newline characters will be included in the
+     * returned string.
+     */
+    readLine(): AsyncResult<string>;
+    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}.
+ */
+declare class CharacterListStream implements CharacterReadStream, CharacterWriteStream {
+    private readonly list;
+    private constructor();
+    static create(initialValues?: JavascriptIterable<string>): CharacterListStream;
+    writeCharacters(characters: JavascriptIterable<string>, startIndex?: number, length?: number): SyncResult<number>;
+    writeString(text: string): AsyncResult<number>;
+    writeLine(text?: string): AsyncResult<number>;
+    /**
+     * Get the number of characters that are available to be read.
+     */
+    getAvailableCharacterCount(): number;
+    readCharacter(): AsyncResult<string>;
+    readCharacters(count: number): SyncResult<string>;
+    readCharacters(output: string[], startIndex?: number, count?: number): SyncResult<number>;
+    readUntil(searchString: string): AsyncResult<string>;
+    readLine(): AsyncResult<string>;
+}
+
+declare class CharacterReadStreamAsyncIterator implements AsyncIterator$1<string> {
+    private readonly readStream;
+    private current;
+    private started;
+    private constructor();
+    static create(readStream: CharacterReadStream): CharacterReadStreamAsyncIterator;
+    next(): PromiseAsyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): string;
+    start(): PromiseAsyncResult<this>;
+    takeCurrent(): PromiseAsyncResult<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>;
+    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>;
+    [Symbol.asyncIterator](): JavascriptAsyncIterator<string>;
+}
+
+/**
+ * An individual parameter from a {@link CommandLineParameters} object.
+ */
+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;
+    private constructor();
+    /**
+     * 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}.
+     */
+    getValue(): T;
+}
+
+/**
+ * A class that can be used to define and interact with an application's command line interface.
+ */
+declare class CommandLineParameters {
+    private readonly args;
+    private constructor();
+    static create(args: JavascriptIterable<string>): CommandLineParameters;
+}
+
+/**
+ * A type that can be used to compare values.
+ */
+declare abstract class Comparer<TLeft, TRight = TLeft> {
+    /**
+     * Compare the two provided values.
+     * @param left The left value to compare.
+     * @param right The right value to compare.
+     */
+    abstract compare(left: TLeft, right: TRight): Comparison;
+    /**
+     * Get whether the left value is less than the right value.
+     * @param left The left value to compare.
+     * @param right The right value to compare.
+     */
+    lessThan(left: TLeft, right: TRight): boolean;
+    /**
+     * Get whether the left value is less than or equal to the right value.
+     * @param left The left value to compare.
+     * @param right The right value to compare.
+     */
+    lessThanOrEqual(left: TLeft, right: TRight): boolean;
+    /**
+     * Get whether the left value equals the right value.
+     * @param left The left value to compare.
+     * @param right The right value to compare.
+     */
+    equal(left: TLeft, right: TRight): boolean;
+    /**
+     * Get whether the left value is greater than or equal to the right value.
+     * @param left The left value to compare.
+     * @param right The right value to compare.
+     */
+    greaterThanOrEqualTo(left: TLeft, right: TRight): boolean;
+    /**
+     * Get whether the left value is greater than the right value.
+     * @param left The left value to compare.
+     * @param right The right value to compare.
+     */
+    greaterThan(left: TLeft, right: TRight): boolean;
+    /**
+     * Attempt to compare the left and right values. The comparison will be done on whether they are
+     * the same value (left === right) or whether one is undefined or null. If they aren't the same
+     * value and neither is undefined or null, then this function can't compare them and will return
+     * undefined.
+     * @param left The left value of the comparison.
+     * @param right The right value of the comparison.
+     */
+    static compareSameUndefinedNull(left: unknown, right: unknown): Comparison | undefined;
+    /**
+     * Get whether the left and right values are equal. The comparison will be done on whether they
+     * are the same value (left === right) or whether one is undefined or null. If they aren't the
+     * same value and neither is undefined or null, then this function can't determine whether they
+     * are equal and will return undefined.
+     * @param left The left value of the comparison.
+     * @param right The right value of the comparison.
+     */
+    static equalSameUndefinedNull(left: unknown, right: unknown): boolean | undefined;
+    static compareNumbers(left: number | undefined | null, right: number | undefined | null): Comparison;
+}
+
+declare class ConcatenateIterable<T> implements Iterable$1<T> {
+    private readonly innerIterables;
+    private constructor();
+    static create<T>(innerIterable: Iterable$1<T>, ...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterable<T>;
+    iterate(): Iterator$1<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>;
+    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> {
+    private readonly innerIterators;
+    private constructor();
+    static create<T>(...toConcatenate: JavascriptIterable<T>[]): ConcatenateIterator<T>;
+    next(): SyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): T;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<T>;
+}
+
+/**
+ * A collection of condition methods that can be used to assert the state of an application.
+ */
+declare class MutableCondition implements Condition {
+    private toStringFunctions;
+    private equalFunctions;
+    private createErrorFunction;
+    protected constructor();
+    private static defaultCreateErrorFunction;
+    /**
+     * Create a new {@link MutableCondition} object.
+     */
+    static create(): MutableCondition;
+    /**
+     * Set the {@link ToStringFunctions} that will be used to convert values to their {@link String}
+     * representations.
+     * @param toStringFunctions The {@link ToStringFunctions} that will be used to convert values to
+     * their {@link String} representations.
+     * @returns This object for method chaining.
+     */
+    setToStringFunctions(toStringFunctions: ToStringFunctions): this;
+    /**
+     * Set the {@link EqualFunctions} that will be used to determine if values are equal.
+     * @param equalFunctions The {@link EqualFunctions} that will be used to determine if values are
+     * equal.
+     * @returns This object for method chaining.
+     */
+    setEqualFunctions(equalFunctions: EqualFunctions): this;
+    /**
+     * Set the {@link Function} that will be used to create {@link Error}s.
+     * @param createErrorFunction The {@link Function} to use to create {@link Error}.
+     * @returns This object for method chaining.
+     */
+    setCreateErrorFunction(createErrorFunction: (message: string) => Error): this;
+    assertUndefined(value: unknown, expression?: string, message?: string): asserts value is undefined;
+    assertNotUndefined<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Get whether the provided values are equal.
+     * @param left The left part of the comparison.
+     * @param right The right part of the comparison.
+     */
+    areEqual(left: unknown, right: unknown): boolean;
+    /**
+     * Get the {@link String} representation of the provided value.
+     * @param value The value to get the {@link String} representation of.
+     */
+    toValueString(value: unknown): string;
+    /**
+     * Create an {@link Error} based on the provided {@link AssertMessageParameters}.
+     * @param parameters The {@link AssertMessageParameters} that define how the should be made.
+     */
+    createError(parameters: AssertMessageParameters): Error;
+    /**
+     * Create an error message based on the provided parameters.
+     * @param parameters The parameters to use to create the error message.
+     */
+    static createErrorMessage(parameters: AssertMessageParameters): string;
+    assertNotUndefinedAndNotNull<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    assertTrue(value: boolean, expression?: string, message?: string): asserts value is true;
+    assertFalse(value: boolean, expression?: string, message?: string): asserts value is false;
+    assertSame<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    assertNotSame<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    assertEqual<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    assertNotEqual<T>(notExpected: T, actual: T, expression?: string, message?: string): void;
+    assertNotEmpty<T extends JavascriptIterable<unknown> | string | null | undefined>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    assertLessThan(value: number, upperBound: number, expression?: string, message?: string): void;
+    assertLessThanOrEqualTo(value: number, upperBound: number, expression?: string, message?: string): void;
+    assertGreaterThanOrEqualTo(value: number, lowerBound: number, expression?: string, message?: string): void;
+    assertGreaterThan(value: number, lowerBound: number, expression?: string, message?: string): void;
+    assertBetween(lowerBound: number, value: number, upperBound: number, expression?: string, message?: string): void;
+    assertAccessIndex(index: number, count: number, expression?: string, message?: string): void;
+    assertInsertIndex(index: number, count: number, expression?: string, message?: string): void;
+    assertOneOf<T>(possibilities: JavascriptIterable<T>, value: T, expression?: string, message?: string): void;
+    assertByte(value: number, expression?: string, message?: string): void;
+    assertInteger(value: number, expression?: string, message?: string): void;
+    assertCharacter(value: string, expression?: string, message?: string): void;
+    assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string): asserts value is T;
+    assertInstanceOf<T>(parameters: {
+        value: unknown;
+        type: Type<T>;
+        typeCheck?: (value: unknown) => value is T;
+        expression?: string;
+        message?: string;
+    }): void;
+    assertInstanceOf<T>(parametersOrValue: unknown | {
+        value: unknown;
+        type: Type<T>;
+        typeCheck?: (value: unknown) => value is T;
+        expression?: string;
+        message?: string;
+    }, type?: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string): void;
+}
+
+/**
+ * A collection of condition methods that can be used to assert the state of an application.
+ */
+declare abstract class Condition {
+    protected constructor();
+    /**
+     * Create a new {@link MutableCondition} object.
+     */
+    static create(): MutableCondition;
+    /**
+     * Assert that the provided value is undefined.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    assertUndefined(value: unknown, expression?: string, message?: string): asserts value is undefined;
+    /**
+     * Assert that the provided value is undefined.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertUndefined(condition: Condition, value: unknown, expression?: string, message?: string): asserts value is undefined;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    assertNotUndefined<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertNotUndefined<T>(condition: Condition, value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    assertNotUndefinedAndNotNull<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertNotUndefinedAndNotNull<T>(condition: Condition, value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is true.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    assertTrue(value: boolean, expression?: string, message?: string): asserts value is true;
+    /**
+     * Assert that the provided value is true.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertTrue(condition: Condition, value: boolean, expression?: string, message?: string): asserts value is true;
+    /**
+     * Assert that the provided value is false.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    assertFalse(value: boolean, expression?: string, message?: string): asserts value is false;
+    /**
+     * Assert that the provided value is false.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertFalse(condition: Condition, value: boolean, expression?: string, message?: string): asserts value is false;
+    /**
+     * Assert that the provided actual value is the same as the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertSame<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is not the same as the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertNotSame<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is equal to the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertEqual<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is not equal to the provided expected value.
+     * @param notExpected The not expected value.
+     * @param actual The actual value.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertNotEqual<T>(notExpected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is not empty.
+     * @param value The value to check.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertNotEmpty(value: JavascriptIterable<unknown> | string | undefined | null, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is less than the provided upperBound.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertLessThan(value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is less than or equal to the provided upperBound.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertLessThanOrEqualTo(value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is greater than or equal to the provided lowerBound.
+     * @param value The value to check.
+     * @param lowerBound The lowerBound that the value must be greater than or equal to.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertGreaterThanOrEqualTo(value: number, lowerBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is greater than the provided lowerBound.
+     * @param value The value to check.
+     * @param lowerBound The lowerBound that the value must be greater than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertGreaterThan(value: number, lowerBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is greater than or equal to the lowerBound and less than or equal to
+     * the upperBound.
+     * @param lowerBound The lowerBound that the value must be greater than or equal to.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than or equal to.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    abstract assertBetween(lowerBound: number, value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the index is within the access bounds of an indexable with the provided count.
+     * @param index The index to check.
+     * @param count The number of elements in the indexable.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    assertAccessIndex(index: number, count: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the index is within the access bounds of an indexable with the provided count.
+     * @param index The index to check.
+     * @param count The number of elements in the indexable.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertAccessIndex(condition: Condition, index: number, count: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the index is within the insertion bounds of a {@link List} with the provided count.
+     * @param index The index to check.
+     * @param count The number of elements in the indexable.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    assertInsertIndex(index: number, count: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the index is within the insertion bounds of a {@link List} with the provided count.
+     * @param index The index to check.
+     * @param count The number of elements in the indexable.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertInsertIndex(condition: Condition, index: number, count: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is one of the possibilities.
+     * @param possibilities The possible values that the value can be.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    abstract assertOneOf<T>(possibilities: JavascriptIterable<T>, value: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is within the bounds of a byte.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    assertByte(value: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is within the bounds of a byte.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertByte(condition: Condition, value: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is an integer.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    abstract assertInteger(value: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is an instance of the provided {@link Type}.
+     * @param value The value to check.
+     * @param type The {@link Type} to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    abstract assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string): asserts value is T;
+    /**
+     * Assert that the provided value is an instance of the provided {@link Type}.
+     * @param value The value to check.
+     * @param type The {@link Type} to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    abstract assertInstanceOf<T>(parameters: {
+        value: unknown;
+        type: Type<T>;
+        typeCheck?: (value: unknown) => value is T;
+        expression?: string;
+        message?: string;
+    }): void;
+}
+
+declare class HttpHeader {
+    private readonly name;
+    private readonly value;
+    private constructor();
+    static create(name: string, value: string): HttpHeader;
+    getName(): string;
+    getValue(): string;
+    toString(): string;
+}
+
+declare class MutableHttpHeaders implements HttpHeaders {
+    private readonly headers;
+    private constructor();
+    static create(headers?: JavascriptIterable<HttpHeader>): MutableHttpHeaders;
+    iterate(): Iterator$1<HttpHeader>;
+    get(headerName: string): SyncResult<HttpHeader>;
+    getValue(headerName: string): SyncResult<string>;
+    /**
+     * Set a {@link HttpHeader} value in this collection. This will overwrite any existing
+     * {@link HttpHeader} with the same name.
+     * @param headerName The name of the header to set.
+     * @param headerValue The value of the header to set.
+     */
+    set(headerName: string, headerValue: string): this;
+    set(header: HttpHeader): this;
+    setAll(headers: JavascriptIterable<HttpHeader>): this;
+    setContentType(contentType: string): this;
+    getContentType(): SyncResult<HttpHeader>;
+    getContentTypeValue(): SyncResult<string>;
+    getCount(): SyncResult<number>;
+    toArray(): SyncResult<HttpHeader[]>;
+    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>;
+    first(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>;
+    last(condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>;
+    [Symbol.iterator](): JavascriptIterator<HttpHeader>;
+    contains(value: HttpHeader, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+}
+
+/**
+ * A collection of {@link HttpHeader}s.
+ */
+declare abstract class HttpHeaders implements Iterable$1<HttpHeader> {
+    static readonly contentTypeHeaderName: string;
+    static create(headers?: JavascriptIterable<HttpHeader>): MutableHttpHeaders;
+    /**
+     * Get the header with the provided name.
+     * @param headerName The name of the header.
+     */
+    abstract get(headerName: string): SyncResult<HttpHeader>;
+    /**
+     * Get the value of the header with the provided name.
+     * @param headerName The name of the header.
+     */
+    abstract getValue(headerName: string): SyncResult<string>;
+    getContentType(): AsyncResult<HttpHeader>;
+    static getContentType(headers: HttpHeaders): AsyncResult<HttpHeader>;
+    getContentTypeValue(): AsyncResult<string>;
+    static getContentTypeValue(headers: HttpHeaders): AsyncResult<string>;
+    /**
+     * Get an {@link Iterator} that can be used to iterate through the {@link HttpHeader}s in this
+     * collection.
+     */
+    abstract iterate(): Iterator$1<HttpHeader>;
+    /**
+     * Get the {@link HttpHeader}s in this {@link HttpHeaders} object as an array.
+     */
+    toArray(): SyncResult<HttpHeader[]>;
+    static toArray(headers: HttpHeaders): SyncResult<HttpHeader[]>;
+    any(): SyncResult<boolean>;
+    static any(headers: HttpHeaders): SyncResult<boolean>;
+    getCount(): SyncResult<number>;
+    static getCount(headers: HttpHeaders): SyncResult<number>;
+    equals(right: JavascriptIterable<HttpHeader>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    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>;
+    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>;
+    static last(headers: HttpHeaders, condition?: (value: HttpHeader) => (boolean | SyncResult<boolean>)): SyncResult<HttpHeader>;
+    [Symbol.iterator](): JavascriptIterator<HttpHeader>;
+    static [Symbol.iterator](headers: HttpHeaders): JavascriptIterator<HttpHeader>;
+    contains(value: HttpHeader, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static contains(headers: HttpHeaders, value: HttpHeader, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+}
+
+declare enum HttpMethod {
+    /**
+     * The GET method requests a representation of the specified resource. Requests using GET should
+     * only retrieve data and should not contain a request content.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/GET
+     */
+    GET = 0,
+    /**
+     * The HEAD method asks for a response identical to a GET request, but without a response body.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/HEAD
+     */
+    HEAD = 1,
+    /**
+     * The POST method submits an entity to the specified resource, often causing a change in state
+     * or side effects on the server.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/POST
+     */
+    POST = 2,
+    /**
+     * The PUT method replaces all current representations of the target resource with the request
+     * content.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/PUT
+     */
+    PUT = 3,
+    /**
+     * The DELETE method deletes the specified resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/DELETE
+     */
+    DELETE = 4,
+    /**
+     * The CONNECT method establishes a tunnel to the server identified by the target resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/CONNECT
+     */
+    CONNECT = 5,
+    /**
+     * The OPTIONS method describes the communication options for the target resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/OPTIONS
+     */
+    OPTIONS = 6,
+    /**
+     * The TRACE method performs a message loop-back test along the path to the target resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/TRACE
+     */
+    TRACE = 7,
+    /**
+     * The PATCH method applies partial modifications to a resource.
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/PATCH
+     */
+    PATCH = 8
+}
+/**
+ * Parse a {@link HttpMethod} from the provided text.
+ * @param text The text to parse.
+ */
+declare function parseHttpMethod(text: string): SyncResult<HttpMethod>;
+/**
+ * Get the string representation of the provided {@link HttpMethod}.
+ * @param httpMethod The {@link HttpMethod} to get the string representation of.
+ */
+declare function httpMethodToString(httpMethod: HttpMethod): string;
+
+/**
+ * A HTTP request that is sent out by a {@link HttpClient}.
+ */
+declare class HttpOutgoingRequest {
+    private method;
+    private url;
+    private readonly headers;
+    private body;
+    private constructor();
+    static create(method: HttpMethod, url: string): HttpOutgoingRequest;
+    /**
+     * Create a new {@link HttpOutgoingRequest} with a GET {@link HttpMethod}.
+     * @param url The target URL for the {@link HttpOutgoingRequest}.
+     */
+    static get(url: string): HttpOutgoingRequest;
+    /**
+     * Get the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+     */
+    getMethod(): HttpMethod;
+    /**
+     * Set the {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+     * @param method The {@link HttpMethod} for this {@link HttpOutgoingRequest}.
+     */
+    setMethod(method: HttpMethod): this;
+    /**
+     * Get this {@link HttpOutgoingRequest}'s target URL.
+     */
+    getURL(): string;
+    /**
+     * Set the URL that this request will be sent to.
+     * @param url The URL to send this request to.
+     */
+    setURL(url: string): this;
+    /**
+     * Get the {@link HttpHeaders} that will be sent.
+     */
+    getHeaders(): HttpHeaders;
+    getHeader(headerName: string): SyncResult<HttpHeader>;
+    getHeaderValue(headerName: string): SyncResult<string>;
+    /**
+     * Get the body that will be sent.
+     */
+    getBody(): string;
+    setBody(body: string): this;
+}
+
+/**
+ * The response from a {@link HttpClient}'s sendRequest() method.
+ */
+declare abstract class HttpIncomingResponse {
+    abstract getStatusCode(): number;
+    abstract getHeaders(): AsyncResult<HttpHeaders>;
+    abstract getHeader(headerName: string): AsyncResult<HttpHeader>;
+    abstract getHeaderValue(headerName: string): AsyncResult<string>;
+    abstract getBody(): AsyncResult<string>;
+}
+
+/**
+ * An object that can make HTTP network requests.
+ */
+declare abstract class HttpClient {
+    static create(): HttpClient;
+    /**
+     * Send the provided {@link HttpOutgoingRequest}.
+     * @param request The {@link HttpOutgoingRequest} to send.
+     */
+    abstract sendRequest(request: HttpOutgoingRequest): AsyncResult<HttpIncomingResponse>;
+    /**
+     * Send a GET {@link HttpOutgoingRequest} to the provided URL.
+     * @param url The URL to send the GET {@link HttpOutgoingRequest} to.
+     */
+    sendGetRequest(url: string): AsyncResult<HttpIncomingResponse>;
+    static sendGetRequest(httpClient: HttpClient, url: string): AsyncResult<HttpIncomingResponse>;
+}
+
+/**
+ * A HTTP request that is received by a {@link HttpServer}.
+ */
+declare abstract class HttpIncomingRequest {
+    /**
+     * Get the {@link HttpMethod} of the request.
+     */
+    abstract getMethod(): HttpMethod;
+    abstract getHost(): AsyncResult<string>;
+    /**
+     * Get the path component of the requested URL.
+     */
+    abstract getURLPath(): string;
+    abstract getHeaders(): AsyncResult<HttpHeaders>;
+    abstract getHeader(headerName: string): AsyncResult<HttpHeader>;
+    abstract getHeaderValue(headerName: string): AsyncResult<string>;
+    abstract getBody(): AsyncResult<string>;
+}
+
+/**
+ * A HTTP response that is sent out by an {@link HttpServer}.
+ */
+declare class HttpOutgoingResponse {
+    private statusCode;
+    private readonly headers;
+    private body;
+    private constructor();
+    static create(): HttpOutgoingResponse;
+    /**
+     * Get the status code of this {@link HttpOutgoingResponse}.
+     */
+    getStatusCode(): number;
+    /**
+     * Set the status code of this {@link HttpOutgoingResponse}.
+     * @param statusCode The status code of this {@link HttpOutgoingResponse}.
+     */
+    setStatusCode(statusCode: number): this;
+    getHeaders(): HttpHeaders;
+    /**
+     * Get the HTTP header with the provided name or return a {@link NotFoundError} if the header
+     * doesn't exist.
+     * @param headerName The name of the header to get.
+     */
+    getHeader(headerName: string): SyncResult<HttpHeader>;
+    /**
+     * Get the value of the header with the provided name or return a {@link NotFoundError} if the
+     * header doesn't exist.
+     * @param headerName The name of the header value to get.
+     */
+    getHeaderValue(headerName: string): SyncResult<string>;
+    /**
+     * Set the HTTP header in this {@link HttpOutgoingResponse}.
+     * @param headerName The name of the HTTP header.
+     * @param headerValue The value of the HTTP header.
+     */
+    setHeader(headerName: string, headerValue: string): this;
+    setContentTypeHeader(contentType: string): this;
+    /**
+     * Get the body of this {@link HttpOutgoingResponse}.
+     */
+    getBody(): string;
+    /**
+     * Set the body of this {@link HttpOutgoingResponse}.
+     * @param body The body for this {@link HttpOutgoingResponse}.
+     */
+    setBody(body: string): this;
+}
+
+declare abstract class HttpServer implements Disposable {
+    abstract dispose(): AsyncResult<boolean>;
+    abstract isDisposed(): boolean;
+    /**
+     * Add the provided request handler so it will be invoked when a request is received for the
+     * provided path.
+     * @param requestPath The path that will cause the provided handler to be invoked.
+     * @param handler The function that will be invoked when the
+     */
+    abstract addRequestHandler(requestPath: string, handler: (request: HttpIncomingRequest, response: HttpOutgoingResponse) => AsyncResult<void>): void;
+    /**
+     * Set the default request handler that will be invoked when no other request handlers match an
+     * {@link HttpIncomingRequest}.
+     * @param handler The handler that will be invoked when no other request handlers match an
+     * {@link HttpIncomingRequest}.
+     */
+    abstract setDefaultRequestHandler(handler: (request: HttpIncomingRequest, response: HttpOutgoingResponse) => AsyncResult<void>): void;
+    /**
+     * Start listening for incoming connections on the provided port number. The returned
+     * {@link AsyncResult} will complete when the server is disposed.
+     * @param portNumber The port number to start listening on.
+     */
+    abstract start(portNumber: number): AsyncResult<void>;
+}
+
+/**
+ * An object that provides access to the network.
+ */
+declare abstract class Network {
+    /**
+     * Create a new {@link HttpServer} that is connected to this {@link Network}.
+     */
+    abstract createHttpServer(): HttpServer;
+    /**
+     * Create a new {@link HttpClient} that is connected to this {@link Network}.
+     */
+    abstract createHttpClient(): HttpClient;
+}
+
+declare class Property<T> {
+    private readonly getter;
+    private readonly setter;
+    private constructor();
+    static create<T>(getter: () => T, setter: (value: T) => void): Property<T>;
+    static create<T>(options: {
+        getter: () => T;
+        setter: (value: T) => void;
+    }): Property<T>;
+    static create<T>(initialValue: T): Property<T>;
+    getValue(): T;
+    setValue(value: T): this;
+    toString(): string;
+}
+
+/**
+ * An object that provides all of the resources that are available to the current process.
+ */
+declare class CurrentProcess {
+    private args;
+    private parameters;
+    private outputWriteStream;
+    private exitCodeProperty;
+    private network;
+    private constructor();
+    static create(): CurrentProcess;
+    static run(action: (currentProcess: CurrentProcess) => void | number | Promise<void | number>): Promise<void>;
+    getArguments(): JavascriptIterable<string>;
+    setArguments(args: JavascriptIterable<string>): this;
+    getParameters(): CommandLineParameters;
+    getOutputWriteStream(): CharacterWriteStream;
+    setOutputWriteStream(outputWriteStream: CharacterWriteStream): this;
+    getExitCode(): number;
+    setExitCode(exitCode: number): this;
+    getExitCodeProperty(): Property<number>;
+    setExitCodeProperty(exitCodeProperty: Property<number>): this;
+    getNetwork(): Network;
+    setNetwork(network: Network): this;
+}
+
+declare abstract class DateTime {
+    static parse(text: string): DateTime;
+    static now(): DateTime;
+    abstract getYear(): number;
+    abstract getMonth(): number;
+    abstract getDay(): number;
+    abstract getHour(): number;
+    abstract getMinute(): number;
+    abstract getSecond(): number;
+    abstract addDays(days: number): DateTime;
+    /**
+     * Compare this {@link DateTime} to the provided {@link DateTime}. If this {@link DateTime} is
+     * less than the provided {@link DateTime}, then a negative number will be returned, 0 if
+     * they're equal, or a positive number if this {@link DateTime} is greater than the provided
+     * {@link DateTime}.
+     * @param dateTime The {@link DateTime} to compare to this {@link DateTime}.
+     */
+    compareTo(dateTime: DateTime, compareTimes: boolean): number;
+    static compareTo(left: DateTime, right: DateTime, compareTimes: boolean): number;
+    lessThan(dateTime: DateTime, compareTimes: boolean): boolean;
+    static lessThan(left: DateTime, right: DateTime, compareTimes: boolean): boolean;
+    lessThanOrEqualTo(dateTime: DateTime, compareTimes: boolean): boolean;
+    static lessThanOrEqualTo(left: DateTime, right: DateTime, compareTimes: boolean): boolean;
+    equals(dateTime: DateTime, compareTimes: boolean): boolean;
+    static equals(left: DateTime, right: DateTime, compareTimes: boolean): boolean;
+    greaterThanOrEqualTo(dateTime: DateTime, compareTimes: boolean): boolean;
+    static greaterThanOrEqualTo(left: DateTime, right: DateTime, compareTimes: boolean): boolean;
+    greaterThan(dateTime: DateTime, compareTimes: boolean): boolean;
+    static greaterThan(left: DateTime, right: DateTime, compareTimes: boolean): boolean;
+    get debug(): string;
+    static debug(dateTime: DateTime): string;
+    abstract toString(): string;
+    abstract toDateString(): string;
+}
+
+/**
+ * An object that can be used to implement a search algorithm.
+ */
+declare abstract class SearchControl<TVisit, TResult> {
+    /**
+     * Add the provided value to the to-visit list.
+     * @param value The value to add to the to-visit list.
+     */
+    abstract addToVisit(value: TVisit): void;
+    /**
+     * Add the provided values to the to-visit list.
+     * @param values The values to add to the to-visit list.
+     */
+    abstract addAllToVisit(values: JavascriptIterable<TVisit>): void;
+    /**
+     * Get whether the provided value has already been visited.
+     * @param value The value to check.
+     */
+    abstract hasVisited(value: TVisit): boolean;
+    /**
+     * Add the provided value to the list of values to be returned.
+     * @param value The value to add.
+     */
+    abstract addResult(value: TResult): void;
+    /**
+     * Add the provided values to the list of values to be returned.
+     * @param values The values to add.
+     */
+    abstract addResults(values: JavascriptIterable<TResult>): void;
+    /**
+     * Immediately stop the search.
+     */
+    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>(parameters: {
+    initialToVisit: JavascriptIterable<TVisit>;
+    searchAction: (searchControl: SearchControl<TVisit, TResult>, current: TVisit) => void;
+}): Iterator$1<TResult>;
+
+/**
+ * An {@link Error} that is created when something is empty.
+ */
+declare class EmptyError extends Error {
+    constructor(message?: string);
+}
+
+declare function andList(values: JavascriptIterable<string>): string;
+declare function orList(values: JavascriptIterable<string>): string;
+
+/**
+ * An {@link HttpIncomingResponse} that comes from a {@link FetchHttpClient}.
+ */
+declare class FetchHttpIncomingResponse extends HttpIncomingResponse {
+    private readonly response;
+    private constructor();
+    static create(response: Response): FetchHttpIncomingResponse;
+    getStatusCode(): number;
+    getHeaders(): SyncResult<HttpHeaders>;
+    getHeader(headerName: string): SyncResult<HttpHeader>;
+    getHeaderValue(headerName: string): SyncResult<string>;
+    getBody(): PromiseAsyncResult<string>;
+}
+
+/**
+ * A {@link HttpClient} that uses {@link fetch}() to make network requests.
+ */
+declare class FetchHttpClient implements HttpClient {
+    protected constructor();
+    static create(): FetchHttpClient;
+    sendRequest(request: HttpOutgoingRequest): PromiseAsyncResult<FetchHttpIncomingResponse>;
+    sendGetRequest(url: string): PromiseAsyncResult<FetchHttpIncomingResponse>;
+    static convertMethod(method: HttpMethod): string;
+}
+
+declare class FlatMapIterable<TInput, TOutput> implements Iterable$1<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>;
+    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>;
+    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> {
+    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>;
+    next(): SyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): TOutput;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<TOutput>;
+}
+
+/**
+ * A control that can be used to interact with a {@link Generator} while it is generating values.
+ */
+interface GeneratorControl<T> {
+    /**
+     * Add the provided value to the list of values that the {@link Generator} will return.
+     * @param value The value to add to the {@link Generator}'s list of values.
+     */
+    addValue(value: T): void;
+    /**
+     * Add the provided values to the list of values that the {@link Generator} will return.
+     * @param returnValues The values to add to the {@link Generator}'s list of values.
+     */
+    addValues(returnValues: JavascriptIterable<T>): void;
+    /**
+     * Get whether the {@link Generator} currently has a value.
+     */
+    hasCurrent(): boolean;
+    /**
+     * Get the current value of the {@link Generator}.
+     */
+    getCurrent(): T;
+}
+declare class Generator<T> implements Iterator$1<T> {
+    private readonly control;
+    private readonly generatorAction;
+    private started;
+    private constructor();
+    static create<T>(generatorAction: (control: GeneratorControl<T>) => (void | T)): Generator<T>;
+    next(): SyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): T;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<T>;
+}
+
+declare class InMemoryCharacterWriteStream extends CharacterWriteStream {
+    private writtenText;
+    private newlineSequence;
+    private constructor();
+    static create(): InMemoryCharacterWriteStream;
+    getNewlineSequence(): string;
+    setNewlineSequence(newlineSequence: string): this;
+    getWrittenText(): string;
+    clearWrittenText(): this;
+    writeString(text: string): SyncResult<number>;
+    writeLine(text?: string): SyncResult<number>;
+}
+
+/**
+ * A JavaScript/TypeScript object that is used to iterate over a collection of values.
+ */
+declare class IteratorToJavascriptIteratorAdapter<T> implements JavascriptIterator<T> {
+    private readonly iterator;
+    private hasStarted;
+    private constructor();
+    static create<T>(iterator: Iterator$1<T>): IteratorToJavascriptIteratorAdapter<T>;
+    next(): JavascriptIteratorResult<T>;
+}
+
+declare class JavascriptArrayList<T> implements List<T> {
+    private readonly array;
+    private constructor();
+    static create<T>(values?: JavascriptIterable<T>): JavascriptArrayList<T>;
+    set(index: number, value: T): this;
+    iterate(): Iterator$1<T>;
+    getCount(): SyncResult<number>;
+    get(index: number): SyncResult<T>;
+    insert(index: number, value: T): this;
+    insertAll(index: number, values: JavascriptIterable<T>): this;
+    removeAt(index: number): SyncResult<T>;
+    removeFirst(): SyncResult<T>;
+    removeLast(): SyncResult<T>;
+    add(value: T): this;
+    addAll(values: JavascriptIterable<T>): this;
+    remove(value: T, equalFunctions?: EqualFunctions): SyncResult<T>;
+    toArray(): SyncResult<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>;
+    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> {
+    private readonly javascriptIterator;
+    private javascriptIteratorResult?;
+    private constructor();
+    static create<T>(javascriptIterator: JavascriptAsyncIterator<T> | JavascriptAsyncIterable<T>): JavascriptAsyncIteratorToAsyncIteratorAdapter<T>;
+    next(): PromiseAsyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): T;
+    start(): PromiseAsyncResult<this>;
+    takeCurrent(): PromiseAsyncResult<T>;
+    any(): PromiseAsyncResult<boolean>;
+    getCount(): PromiseAsyncResult<number>;
+    toArray(): PromiseAsyncResult<T[]>;
+    map<TOutput>(mapping: (value: T) => (TOutput | PromiseLike<TOutput>)): AsyncIterator$1<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>;
+}
+
+declare class JavascriptIteratorToIteratorAdapter<T> implements Iterator$1<T> {
+    private readonly javascriptIterator;
+    private javascriptIteratorResult?;
+    private constructor();
+    static create<T>(javascriptIterator: JavascriptIterator<T> | JavascriptIterable<T>): JavascriptIteratorToIteratorAdapter<T>;
+    next(): SyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): T;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    [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>;
+}
+
+/**
+ * Get whether the provided value is {@link Map}.
+ * @param value The value to check.
+ */
+declare function isMutableMap(value: unknown): value is MutableMap<unknown, unknown>;
+/**
+ * A type that maps {@link TKey} values to {@link TValue} values.
+ */
+declare abstract class MutableMap<TKey, TValue> implements Map$1<TKey, TValue> {
+    /**
+     * Create a new instance of the default {@link Map} implementation.
+     */
+    static create<TKey, TValue>(): MutableMap<TKey, TValue>;
+    /**
+     * Iterate over the entries in this {@link MutableMap}.
+     */
+    abstract iterate(): Iterator$1<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>;
+    /**
+     * Get the {@link String} representation of this {@link MutableMap}.
+     */
+    toString(toStringFunctions?: ToStringFunctions): string;
+    /**
+     * 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>;
+    [Symbol.iterator](): JavascriptIterator<MapEntry<TKey, TValue>>;
+    static [Symbol.iterator]<TKey, TValue>(map: MutableMap<TKey, TValue>): JavascriptIterator<MapEntry<TKey, TValue>>;
+    /**
+     * Get the number of entries in this {@link MutableMap}.
+     */
+    getCount(): SyncResult<number>;
+    static getCount<TKey, TValue>(map: MutableMap<TKey, TValue>): SyncResult<number>;
+    first(condition?: (entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>;
+    static first<TKey, TValue>(map: MutableMap<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: MutableMap<TKey, TValue>, condition?: (entry: MapEntry<TKey, TValue>) => (boolean | SyncResult<boolean>)): SyncResult<MapEntry<TKey, TValue>>;
+    /**
+     * Get whether this {@link MutableMap} contains the provided key.
+     * @param key The key to look for.
+     */
+    abstract containsKey(key: TKey): SyncResult<boolean>;
+    /**
+     * Get the value associated with the provided key.
+     * @param key The key of the value to get.
+     */
+    abstract get(key: TKey): SyncResult<TValue>;
+    /**
+     * Set the key/value association in this {@link MutableMap}.
+     * @param key The key associated with the value.
+     * @param value The value associated with the key.
+     */
+    abstract set(key: TKey, value: TValue): this;
+    /**
+     * Get the {@link TValue} associated with the provided {@link TKey}. If the provided
+     * {@link TKey} doesn't exist in this {@link MutableMap}, then invoke the provided {@link valueCreator}
+     * and associate the returned {@link TValue} with the provided {@link TKey}. Then return the new
+     * {@link TValue}.
+     * @param key The {@link TKey} of the {@link TValue} to get.
+     * @param valueCreator The {@link Function} that will be invoked if the {@link TKey} doesn't
+     * exist in this {@link MutableMap}.
+     */
+    getOrSet(key: TKey, valueCreator: () => (TValue | SyncResult<TValue>)): SyncResult<TValue>;
+    /**
+     * Get the {@link TValue} associated with the provided {@link TKey}. If the provided
+     * {@link TKey} doesn't exist in the {@link MutableMap}, then invoke the provided {@link valueCreator}
+     * and associate the returned {@link TValue} with the provided {@link TKey}. Then return the new
+     * {@link TValue}.
+     * @param key The {@link TKey} of the {@link TValue} to get.
+     * @param valueCreator The {@link Function} that will be invoked if the {@link TKey} doesn't
+     * exist in this {@link MutableMap}.
+     */
+    static getOrSet<TKey, TValue>(map: MutableMap<TKey, TValue>, key: TKey, valueCreator: () => (TValue | SyncResult<TValue>)): SyncResult<TValue>;
+    /**
+     * Remove the provided {@link TKey} from this {@link MutableMap}. If the {@link TKey} doesn't exist in
+     * this {@link MutableMap}, then return a {@link NotFoundError}. If the {@link TKey} does exist, then
+     * return the {@link TValue} that was associated with it.
+     * @param key The {@link TKey} to remove from this {@link MutableMap}.
+     */
+    abstract remove(key: TKey): SyncResult<TValue>;
+    /**
+     * Iterate over the keys in this {@link MutableMap}.
+     */
+    iterateKeys(): Iterator$1<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>;
+    /**
+     * Iterate over the values in this {@link MutableMap}.
+     */
+    iterateValues(): Iterator$1<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>;
+    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>;
+}
+
+/**
+ * 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>;
+/**
+ * An entry within a {@link Map}.
+ */
+interface MapEntry<TKey, TValue> {
+    /**
+     * The key of the {@link MapEntry}.
+     */
+    readonly key: TKey;
+    /**
+     * The value of the {@link MapEntry}.
+     */
+    readonly value: 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>> {
+    /**
+     * Create a new instance of the default {@link MutableMap} implementation.
+     */
+    static create<TKey, TValue>(): MutableMap<TKey, TValue>;
+    /**
+     * Iterate over the entries in this {@link Map}.
+     */
+    abstract iterate(): Iterator$1<MapEntry<TKey, TValue>>;
+    any(): SyncResult<boolean>;
+    static any<TKey, TValue>(map: Map$1<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>;
+    /**
+     * Get the {@link String} representation of this {@link Map}.
+     */
+    toString(toStringFunctions?: ToStringFunctions): string;
+    /**
+     * 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>;
+    [Symbol.iterator](): JavascriptIterator<MapEntry<TKey, TValue>>;
+    static [Symbol.iterator]<TKey, TValue>(map: Map$1<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>;
+    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>>;
+    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>>;
+    /**
+     * Get whether this {@link Map} contains the provided key.
+     * @param key The key to look for.
+     */
+    abstract containsKey(key: TKey): SyncResult<boolean>;
+    /**
+     * Get the value associated with the provided key.
+     * @param key The key of the value to get.
+     */
+    abstract get(key: TKey): SyncResult<TValue>;
+    /**
+     * Iterate over the keys in this {@link Map}.
+     */
+    iterateKeys(): Iterator$1<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>;
+    /**
+     * Iterate over the values in this {@link Map}.
+     */
+    iterateValues(): Iterator$1<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>;
+    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>;
+}
+
+declare class JavascriptMapMap<TKey, TValue> implements MutableMap<TKey, TValue> {
+    private readonly javascriptMap;
+    private constructor();
+    static create<TKey, TValue>(): JavascriptMapMap<TKey, TValue>;
+    any(): SyncResult<boolean>;
+    getCount(): SyncResult<number>;
+    containsKey(key: TKey): SyncResult<boolean>;
+    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>;
+    toArray(): SyncResult<MapEntry<TKey, TValue>[]>;
+    equals(right: Iterable$1<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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<MapEntry<TKey, TValue>>;
+    contains(value: MapEntry<TKey, TValue>, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+}
+
+/**
+ * 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> {
+    static create<T>(initialValues?: JavascriptIterable<T>): JavascriptSetSet<T>;
+    /**
+     * Add the provided value to this {@link Set}.
+     * @param value The value to add to this {@link Set}.
+     */
+    abstract add(value: T): this;
+    addAll(values: JavascriptIterable<T>): this;
+    static addAll<T, TSet extends Set$1<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>;
+    toArray(): SyncResult<T[]>;
+    static toArray<T>(set: Set$1<T>): SyncResult<T[]>;
+    any(): SyncResult<boolean>;
+    static any<T>(set: Set$1<T>): SyncResult<boolean>;
+    getCount(): SyncResult<number>;
+    static getCount<T>(set: Set$1<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>;
+    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>;
+    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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<T>;
+    static [Symbol.iterator]<T>(set: Set$1<T>): JavascriptIterator<T>;
+    contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+    static contains<T>(set: Set$1<T>, value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+}
+
+declare class JavascriptSetSet<T> implements Set$1<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>;
+    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>;
+    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>;
+}
+
+/**
+ * A data structure that stores values in a first-in-first-out order.
+ */
+declare abstract class Queue<T> {
+    /**
+     * Create an instance of the default {@link Queue} implementation.
+     * @returns A new {@link Queue} object.
+     */
+    static create<T>(): ListQueue<T>;
+    /**
+     * Get whether there are any values in this {@link Stack}.
+     */
+    abstract any(): AsyncResult<boolean>;
+    /**
+     * Add the provided value onto the end of this {@link Queue}.
+     * @param value The value to add to the end of this {@link Queue}.
+     */
+    abstract add(value: T): AsyncResult<void>;
+    /**
+     * Add the provided values to the end of this {@link Queue}.
+     * @param values The values to add to the end of this {@link Queue}.
+     */
+    abstract addAll(values: JavascriptIterable<T>): AsyncResult<void>;
+    /**
+     * Remove the next value off of this {@link Queue}.
+     */
+    abstract remove(): AsyncResult<T>;
+    /**
+     * Get whether this {@link Stack} contains the provided value.
+     * @param value The value to look for.
+     * @param equalFunctions The functions to use to compare values.
+     */
+    abstract contains(value: T, equalFunctions?: EqualFunctions): AsyncResult<boolean>;
+}
+
+declare class ListQueue<T> implements Queue<T> {
+    private readonly list;
+    private constructor();
+    static create<T>(list?: List<T>): ListQueue<T>;
+    any(): SyncResult<boolean>;
+    add(value: T): SyncResult<void>;
+    addAll(values: JavascriptIterable<T>): SyncResult<void>;
+    remove(): SyncResult<T>;
+    contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+}
+
+/**
+ * A data structure that stores values in a first-in-last-out order.
+ */
+declare abstract class Stack<T> {
+    /**
+     * Create an instance of the default {@link Stack} implementation.
+     * @returns A new {@link Stack} object.
+     */
+    static create<T>(): ListStack<T>;
+    /**
+     * Get whether there are any values in this {@link Stack}.
+     */
+    abstract any(): AsyncResult<boolean>;
+    /**
+     * Push the provided value onto the top of this {@link Stack}.
+     * @param value The value to push on the top of this {@link Stack}.
+     */
+    abstract add(value: T): AsyncResult<void>;
+    /**
+     * Push the provided values onto the top of this {@link Stack}.
+     * @param values The values to push onto this {@link Stack}.
+     */
+    abstract addAll(values: JavascriptIterable<T>): AsyncResult<void>;
+    /**
+     * Remove the top value off of this {@link Stack}.
+     */
+    abstract remove(): AsyncResult<T>;
+    /**
+     * Get whether this {@link Stack} contains the provided value.
+     * @param value The value to look for.
+     * @param equalFunctions The functions to use to compare values.
+     */
+    abstract contains(value: T, equalFunctions?: EqualFunctions): AsyncResult<boolean>;
+}
+
+declare class ListStack<T> implements Stack<T> {
+    private readonly list;
+    private constructor();
+    static create<T>(list?: List<T>): ListStack<T>;
+    any(): SyncResult<boolean>;
+    add(value: T): SyncResult<void>;
+    addAll(values: JavascriptIterable<T>): SyncResult<void>;
+    remove(): SyncResult<T>;
+    contains(value: T, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+}
+
+declare class LuxonDateTime implements DateTime {
+    private readonly dateTime;
+    private constructor();
+    private static create;
+    static parse(text: string): LuxonDateTime;
+    static now(): LuxonDateTime;
+    getYear(): number;
+    getMonth(): number;
+    getDay(): number;
+    getHour(): number;
+    getMinute(): number;
+    getSecond(): number;
+    addDays(days: number): LuxonDateTime;
+    toString(): string;
+    toDateString(): string;
+    compareTo(dateTime: DateTime, compareTimes: boolean): number;
+    lessThan(dateTime: DateTime, compareTimes: boolean): boolean;
+    lessThanOrEqualTo(dateTime: DateTime, compareTimes: boolean): boolean;
+    equals(dateTime: DateTime, compareTimes: boolean): boolean;
+    greaterThanOrEqualTo(dateTime: DateTime, compareTimes: boolean): boolean;
+    greaterThan(dateTime: DateTime, compareTimes: boolean): boolean;
+    get debug(): string;
+}
+
+/**
+ * An {@link AsyncIterator} that maps {@link TInput} values to {@link TOutput} values.
+ */
+declare class MapAsyncIterator<TInput, TOutput> implements AsyncIterator$1<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>;
+    next(): PromiseAsyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): TOutput;
+    start(): PromiseAsyncResult<this>;
+    takeCurrent(): PromiseAsyncResult<TOutput>;
+    any(): PromiseAsyncResult<boolean>;
+    getCount(): PromiseAsyncResult<number>;
+    toArray(): PromiseAsyncResult<TOutput[]>;
+    map<TOutput2>(mapping: (value: TOutput) => (TOutput2 | PromiseLike<TOutput2>)): AsyncIterator$1<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>;
+}
+
+/**
+ * An {@link Iterable} that converts {@link TInput} values to {@link TOutput} values.
+ */
+declare class MapIterable<TInput, TOutput> implements Iterable$1<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>;
+    toArray(): SyncResult<TOutput[]>;
+    equals(right: Iterable$1<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>;
+    [Symbol.iterator](): JavascriptIterator<TOutput>;
+    any(): SyncResult<boolean>;
+    getCount(): SyncResult<number>;
+    first(): SyncResult<TOutput>;
+    last(): SyncResult<TOutput>;
+    contains(value: TOutput, equalFunctions?: EqualFunctions): SyncResult<boolean>;
+}
+
+/**
+ * An {@link Iterator} that maps {@link TInput} values to {@link TOutput} values.
+ */
+declare class MapIterator<TInput, TOutput> implements Iterator$1<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>;
+    next(): SyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): TOutput;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    [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>;
+}
+
+declare class Node<T> {
+    private readonly value;
+    private connectedNodes;
+    private constructor();
+    static create<T>(value: T): Node<T>;
+    getValue(): T;
+    iterateConnectedNodes(): Iterator$1<Node<T>>;
+    addConnectedNode(node: Node<T>): void;
+}
+
+declare class NodeJSCharacterWriteStream extends CharacterWriteStream {
+    private readonly nodeJSWriteStream;
+    private constructor();
+    static create(nodeJSWriteStream: NodeJS.WriteStream): NodeJSCharacterWriteStream;
+    writeString(text: string): PromiseAsyncResult<number>;
+}
+
+declare class NodeJSHttpIncomingRequest extends HttpIncomingRequest {
+    private readonly request;
+    private constructor();
+    static create(request: http.IncomingMessage): NodeJSHttpIncomingRequest;
+    getMethod(): HttpMethod;
+    getHost(): SyncResult<string>;
+    getURLPath(): string;
+    private static toHttpHeader;
+    private static toHttpHeaderValue;
+    getHeaders(): SyncResult<HttpHeaders>;
+    getHeader(headerName: string): SyncResult<HttpHeader>;
+    getHeaderValue(headerName: string): SyncResult<string>;
+    getBody(): SyncResult<string>;
+}
+
+/**
+ * A {@link HttpServer} implementation that uses the Node.js HTTP module.
+ */
+declare class NodeJSHttpServer extends HttpServer {
+    private httpServer;
+    private disposed;
+    private constructor();
+    static create(): NodeJSHttpServer;
+    dispose(): PromiseAsyncResult<boolean>;
+    isDisposed(): boolean;
+    isStarted(): boolean;
+    addRequestHandler(requestPath: string, handler: (request: HttpIncomingRequest, response: HttpOutgoingResponse) => AsyncResult<void>): void;
+    setDefaultRequestHandler(handler: (request: HttpIncomingRequest, response: HttpOutgoingResponse) => AsyncResult<void>): void;
+    start(portNumber: number): PromiseAsyncResult<void>;
+}
+
+/**
+ * An {@link Error} that is thrown when a value is not found.
+ */
+declare class NotFoundError extends Error {
+    constructor(...message: string[]);
+}
+
+/**
+ * A type that encapsulates conditions that should exist before an operation takes place.
+ */
+declare abstract class PostCondition {
+    private static condition;
+    private static getCondition;
+    /**
+     * Assert that the provided value is undefined.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertUndefined(value: unknown, expression?: string, message?: string): asserts value is undefined;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertNotUndefined<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertNotUndefinedAndNotNull<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is true.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertTrue(value: boolean, expression?: string, message?: string): asserts value is true;
+    /**
+     * Assert that the provided value is false.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertFalse(value: boolean, expression?: string, message?: string): asserts value is false;
+    /**
+     * Assert that the provided actual value is the same as the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertSame<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is not the same as the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertNotSame<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is equal to the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertEqual<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is not equal to the provided expected value.
+     * @param notExpected The not expected value.
+     * @param actual The actual value.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertNotEqual<T>(notExpected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is not empty.
+     * @param value The value to check.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertNotEmpty(value: JavascriptIterable<unknown> | string | undefined | null, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is less than the provided upperBound.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertLessThan(value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is less than or equal to the provided upperBound.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertLessThanOrEqualTo(value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is greater than or equal to the provided lowerBound.
+     * @param value The value to check.
+     * @param lowerBound The lowerBound that the value must be greater than or equal to.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertGreaterThanOrEqualTo(value: number, lowerBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is greater than the provided lowerBound.
+     * @param value The value to check.
+     * @param lowerBound The lowerBound that the value must be greater than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertGreaterThan(value: number, lowerBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is greater than or equal to the lowerBound and less than or equal to
+     * the upperBound.
+     * @param lowerBound The lowerBound that the value must be greater than or equal to.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than or equal to.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertBetween(lowerBound: number, value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the index is within the access bounds of an indexable with the provided count.
+     * @param index The index to check.
+     * @param count The number of elements in the indexable.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertAccessIndex(index: number, count: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the index is within the insertion bounds of a {@link List} with the provided count.
+     * @param index The index to check.
+     * @param count The number of elements in the indexable.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertInsertIndex(index: number, count: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is one of the possibilities.
+     * @param possibilities The possible values that the value can be.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertOneOf<T>(possibilities: JavascriptIterable<T>, value: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is within the bounds of a byte.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertByte(value: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is an integer.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertInteger(value: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is a characer (single character string).
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertCharacter(value: string, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is an instance of the provided {@link Type}.
+     * @param value The value to check.
+     * @param type The {@link Type} to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string): asserts value is T;
+    assertInstanceOf<T>(parameters: {
+        value: unknown;
+        type: Type<T>;
+        typeCheck?: (value: unknown) => value is T;
+        expression?: string;
+        message?: string;
+    }): void;
+}
+
+/**
+ * An {@link Error} that is thrown when a post-condition fails.
+ */
+declare class PostConditionError extends Error {
+    constructor(...message: string[]);
+}
+
+/**
+ * A type that encapsulates conditions that should exist before an operation takes place.
+ */
+declare abstract class PreCondition {
+    private static condition;
+    private static getCondition;
+    /**
+     * Assert that the provided value is undefined.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertUndefined(value: unknown, expression?: string, message?: string): asserts value is undefined;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertNotUndefined<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is not undefined and not null.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertNotUndefinedAndNotNull<T>(value: T, expression?: string, message?: string): asserts value is NonNullable<T>;
+    /**
+     * Assert that the provided value is true.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertTrue(value: boolean, expression?: string, message?: string): asserts value is true;
+    /**
+     * Assert that the provided value is false.
+     * @param value The value to check.
+     * @param expression The name of the expression that produced the value.
+     * @param message An additional message that will be included with the error.
+     */
+    static assertFalse(value: boolean, expression?: string, message?: string): asserts value is false;
+    /**
+     * Assert that the provided actual value is the same as the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertSame<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is not the same as the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertNotSame<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is equal to the provided expected value.
+     * @param expected The expected value.
+     * @param actual The actual value.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertEqual<T>(expected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided actual value is not equal to the provided expected value.
+     * @param notExpected The not expected value.
+     * @param actual The actual value.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertNotEqual<T>(notExpected: T, actual: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is not empty.
+     * @param value The value to check.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertNotEmpty(value: JavascriptIterable<unknown> | string | undefined | null, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is less than the provided upperBound.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertLessThan(value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is less than or equal to the provided upperBound.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertLessThanOrEqualTo(value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is greater than or equal to the provided lowerBound.
+     * @param value The value to check.
+     * @param lowerBound The lowerBound that the value must be greater than or equal to.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertGreaterThanOrEqualTo(value: number, lowerBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is greater than the provided lowerBound.
+     * @param value The value to check.
+     * @param lowerBound The lowerBound that the value must be greater than.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertGreaterThan(value: number, lowerBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is greater than or equal to the lowerBound and less than or equal to
+     * the upperBound.
+     * @param lowerBound The lowerBound that the value must be greater than or equal to.
+     * @param value The value to check.
+     * @param upperBound The upperBound that the value must be less than or equal to.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertBetween(lowerBound: number, value: number, upperBound: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the index is within the access bounds of an indexable with the provided count.
+     * @param index The index to check.
+     * @param count The number of elements in the indexable.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertAccessIndex(index: number, count: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the index is within the insertion bounds of a {@link List} with the provided count.
+     * @param index The index to check.
+     * @param count The number of elements in the indexable.
+     * @param expression  The expression that produced the actual value.
+     * @param message An optional message that describes the scenario.
+     */
+    static assertInsertIndex(index: number, count: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is one of the possibilities.
+     * @param possibilities The possible values that the value can be.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertOneOf<T>(possibilities: JavascriptIterable<T>, value: T, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is within the bounds of a byte.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertByte(value: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is an integer.
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertInteger(value: number, expression?: string, message?: string): void;
+    /**
+     * Assert that the value is a characer (single character string).
+     * @param value The value to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    static assertCharacter(value: string, expression?: string, message?: string): void;
+    /**
+     * Assert that the provided value is an instance of the provided {@link Type}.
+     * @param value The value to check.
+     * @param type The {@link Type} to check.
+     * @param expression The expression that produced the value.
+     * @param message An optional error message.
+     */
+    assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T, expression?: string, message?: string): asserts value is T;
+    assertInstanceOf<T>(parameters: {
+        value: unknown;
+        type: Type<T>;
+        typeCheck?: (value: unknown) => value is T;
+        expression?: string;
+        message?: string;
+    }): void;
+}
+
+/**
+ * An {@link Error} that is thrown when a pre-condition fails.
+ */
+declare class PreConditionError extends Error {
+    constructor(...message: string[]);
+}
+
+declare class RealNetwork extends Network {
+    private constructor();
+    static create(): RealNetwork;
+    createHttpServer(): HttpServer;
+    createHttpClient(): HttpClient;
+}
+
+interface RecreationDotGovDivisionDayAvailability {
+    readonly date: DateTime;
+    readonly walkup: boolean;
+    readonly reservationsRemaining: number;
+    readonly totalSpots: number;
+}
+interface RecreationDotGovDivisionAvailabilityJson {
+    readonly bools: {
+        [date: string]: boolean;
+    };
+    readonly rules: {
+        readonly name: string;
+        readonly value: number;
+    }[];
+    readonly quota_type_maps: {
+        readonly ConstantQuotaUsageDaily?: {
+            [date: string]: {
+                readonly is_hidden: boolean;
+                readonly remaining: number;
+                readonly season_type: string;
+                readonly show_walkup: boolean;
+                readonly total: number;
+            };
+        };
+        readonly QuotaUsageByMemberDaily?: {
+            [date: string]: {
+                readonly is_hidden: boolean;
+                readonly remaining: number;
+                readonly season_type: string;
+                readonly show_walkup: boolean;
+                readonly total: number;
+            };
+        };
+    };
+}
+declare class RecreationDotGovDivisionAvailability {
+    readonly json: RecreationDotGovDivisionAvailabilityJson;
+    readonly minimumGroupSize?: number;
+    readonly maximumGroupSize?: number;
+    readonly dayAvailabilities: Iterable$1<RecreationDotGovDivisionDayAvailability>;
+    private constructor();
+    static create(json: RecreationDotGovDivisionAvailabilityJson): RecreationDotGovDivisionAvailability;
+}
+interface RecreationDotGovDivisionJson {
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    readonly district: string;
+}
+interface RecreationDotGovPermitItineraryJson {
+    readonly id: string;
+    readonly name: string;
+    readonly divisions: {
+        [divisionId: number]: RecreationDotGovDivisionJson;
+    };
+}
+declare class RecreationDotGovError extends Error {
+    constructor(message: string);
+}
+interface RecreationDotGovErrorResponse {
+    readonly error: string;
+}
+declare class RecreationDotGovClient implements HttpClient {
+    private readonly httpClient;
+    private constructor();
+    static create(httpClient: HttpClient): RecreationDotGovClient;
+    sendRequest(request: HttpOutgoingRequest): AsyncResult<HttpIncomingResponse>;
+    sendGetRequest(url: string): AsyncResult<HttpIncomingResponse>;
+    getPermitItinerary(permitItineraryId: string): PromiseAsyncResult<RecreationDotGovPermitItineraryJson>;
+    getDivisionAvailability(permitItineraryId: string, divisionId: string, month: number, year: number, earlyAccessPermitLotteryId?: string): PromiseAsyncResult<RecreationDotGovDivisionAvailability>;
+}
+
+/**
+ * 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> {
+    private readonly innerIterator;
+    private started;
+    private readonly maximumToSkip;
+    private constructor();
+    static create<T>(innerIterator: AsyncIterator$1<T>, maximumToSkip: number): SkipAsyncIterator<T>;
+    next(): PromiseAsyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): T;
+    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>;
+    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>;
+    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>;
+}
+
+/**
+ * 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> {
+    private readonly innerIterator;
+    private started;
+    private readonly maximumToSkip;
+    private constructor();
+    static create<T>(innerIterator: Iterator$1<T>, maximumToSkip: number): SkipIterator<T>;
+    next(): SyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): T;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    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>;
+}
+
+/**
+ * A {@link Comparer} that performs {@link string} comparisons.
+ */
+declare class StringComparer extends Comparer<string> {
+    protected constructor();
+    static create(): StringComparer;
+    compare(left: string, right: string): Comparison;
+    static compare(left: string, right: string): Comparison;
+}
+
+/**
+ * An {@link Iterator} that iterates over the characters in a {@link string}.
+ */
+declare class StringIterator implements Iterator$1<string> {
+    private readonly value;
+    private currentIndex;
+    private started;
+    private constructor();
+    static create(value: string): StringIterator;
+    getCurrentIndex(): number;
+    next(): SyncResult<boolean>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): string;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<string>;
+}
+
+declare function getLength(value: string | undefined | null): number;
+declare function toString(value: undefined | null | {
+    toString(): string;
+}): string;
+/**
+ * Join the provided values with the provided separator in between each value.
+ * @param separator The value to use to separate the individual values.
+ * @param values The values to join.
+ * @returns The joined {@link string}.
+ */
+declare function join(separator: string, values: JavascriptIterable<string>): string;
+declare function join(parameters: {
+    separator: string;
+    values: JavascriptIterable<string>;
+}): string;
+declare function escape(value: string | undefined | null, dontEscape?: string[]): string;
+declare function escape(parameters: {
+    value: string | undefined | null;
+    dontEscape?: string[];
+}): string;
+/**
+ * Get a version of the provided value that is quoted with the provided quote.
+ * @param value The value to quote.
+ * @param quote The quotes to surround the provided value with.
+ */
+declare function quote(value: string | undefined | null, quote?: string): string;
+/**
+ * Get a version of the provided value that is quoted with the provided quote.
+ * @param parameters The parameters to use to invoke this function.
+ */
+declare function quote(parameters: {
+    value: string | undefined | null;
+    quote?: string;
+}): string;
+/**
+ * Get a version of the provided value where the characters are escaped and quoted.
+ * @param value The value to escape and quote.
+ * @param quoteString The quote to surround the value with.
+ * @param dontEscape The characters to not escape.
+ */
+declare function escapeAndQuote(value: string | undefined | null, quoteString?: string, dontEscape?: string[]): string;
+declare function escapeAndQuote(parameters: {
+    value: string | undefined | null;
+    quoteString?: string;
+    dontEscape?: string[];
+}): string;
+/**
+ * Get whether the provided value only contains whitespace characters.
+ * @param value The value to check.
+ */
+declare function isWhitespace(value: string): boolean;
+/**
+ * Get whether the provided value only contains letters.
+ * @param value The value to check.
+ */
+declare function isLetter(value: string): boolean;
+/**
+ * Get whether the provided value only contains letters.
+ * @param value The value to check.
+ */
+declare function isLowercasedLetter(value: string): boolean;
+/**
+ * Get whether the provided value only contains letters.
+ * @param value The value to check.
+ */
+declare function isUppercasedLetter(value: string): boolean;
+/**
+ * Get whether the provided value only contains digits.
+ * @param value The value to check.
+ */
+declare function isDigit(value: string): boolean;
+/**
+ * Get whether the provided value only contains letters and digits.
+ * @param value The value to check.
+ */
+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> {
+    private readonly innerIterator;
+    private started;
+    private readonly maximumToTake;
+    private taken;
+    private constructor();
+    static create<T>(innerIterator: AsyncIterator$1<T>, maximumToTake: number): TakeAsyncIterator<T>;
+    hasCurrent(): boolean;
+    next(): PromiseAsyncResult<boolean>;
+    hasStarted(): boolean;
+    getCurrent(): T;
+    start(): PromiseAsyncResult<this>;
+    takeCurrent(): PromiseAsyncResult<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>;
+    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>;
+}
+
+/**
+ * An {@link Iterator} that iterates over a maximum number of values.
+ */
+declare class TakeIterator<T> implements Iterator$1<T> {
+    private readonly innerIterator;
+    private started;
+    private readonly maximumToTake;
+    private taken;
+    private constructor();
+    static create<T>(innerIterator: Iterator$1<T>, maximumToTake: number): TakeIterator<T>;
+    hasCurrent(): boolean;
+    next(): SyncResult<boolean>;
+    hasStarted(): boolean;
+    getCurrent(): T;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    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>;
+}
+
+/**
+ * An {@link Iterator} that only returns values that match a condition.
+ */
+declare class WhereAsyncIterator<T> implements AsyncIterator$1<T> {
+    private readonly innerIterator;
+    private started;
+    private readonly condition;
+    private constructor();
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): T;
+    static create<T>(innerIterator: AsyncIterator$1<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>;
+    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>;
+    [Symbol.asyncIterator](): JavascriptAsyncIterator<T>;
+}
+
+/**
+ * An {@link Iterable} that only returns values that match a condition.
+ */
+declare class WhereIterable<T> implements Iterable$1<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>;
+    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>;
+    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>;
+}
+
+/**
+ * An {@link Iterator} that only returns values that match a condition.
+ */
+declare class WhereIterator<T> implements Iterator$1<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>;
+    hasStarted(): boolean;
+    hasCurrent(): boolean;
+    getCurrent(): T;
+    next(): SyncResult<boolean>;
+    start(): SyncResult<this>;
+    takeCurrent(): SyncResult<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>;
+    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>;
+    [Symbol.iterator](): JavascriptIterator<T>;
+}
+
+interface WonderlandTrailLocation {
+    readonly name: string;
+    readonly trailhead: boolean;
+    readonly foodCacheStorage: boolean;
+    readonly divisionId: string;
+    readonly groupSiteDivisionId: string;
+    readonly latitude: number;
+    readonly longitude: number;
+    readonly elevationFeet: number;
+}
+declare function isWonderlandTrailLocation(value: unknown): value is WonderlandTrailLocation;
+declare abstract class WonderlandTrailLocations {
+    static readonly graniteCreek: WonderlandTrailLocation;
+    static readonly sunriseCamp: WonderlandTrailLocation;
+    static readonly sunriseVisitorCenter: WonderlandTrailLocation;
+    static readonly whiteRiver: WonderlandTrailLocation;
+    static readonly fryingPanCreek: WonderlandTrailLocation;
+    static readonly summerland: WonderlandTrailLocation;
+    static readonly indianBar: WonderlandTrailLocation;
+    static readonly nickelCreek: WonderlandTrailLocation;
+    static readonly boxCanyon: WonderlandTrailLocation;
+    static readonly mapleCreek: WonderlandTrailLocation;
+    static readonly reflectionLakes: WonderlandTrailLocation;
+    static readonly paradiseRiver: WonderlandTrailLocation;
+    static readonly longmire: WonderlandTrailLocation;
+    static readonly pyramidCreek: WonderlandTrailLocation;
+    static readonly devilsDream: WonderlandTrailLocation;
+    static readonly southPuyallupRiver: WonderlandTrailLocation;
+    static readonly klapatchePark: WonderlandTrailLocation;
+    static readonly northPuyallupRiver: WonderlandTrailLocation;
+    static readonly goldenLakes: WonderlandTrailLocation;
+    static readonly southMowichRiver: WonderlandTrailLocation;
+    static readonly mowichLake: WonderlandTrailLocation;
+    static readonly eaglesRoost: WonderlandTrailLocation;
+    static readonly cataractValley: WonderlandTrailLocation;
+    static readonly ipsutCreek: WonderlandTrailLocation;
+    static readonly carbonRiver: WonderlandTrailLocation;
+    static readonly dickCreek: WonderlandTrailLocation;
+    static readonly mysticLake: WonderlandTrailLocation;
+    static getLocations(): Iterable$1<WonderlandTrailLocation>;
+    static getTrailheads(): Iterable$1<WonderlandTrailLocation>;
+}
+declare enum WonderlandTrailReservationType {
+    Reserved = 0,
+    Walkup = 1
+}
+interface WonderlandTrailAvailabilityType {
+    readonly individualSite?: WonderlandTrailReservationType;
+    readonly groupSite?: WonderlandTrailReservationType;
+}
+declare class WonderlandTrailAvailability {
+    private readonly availabilityMap;
+    private constructor();
+    static create(): WonderlandTrailAvailability;
+    any(): boolean;
+    addAvailability(location: WonderlandTrailLocation, date: DateTime, individualSite?: WonderlandTrailReservationType, groupSite?: WonderlandTrailReservationType): void;
+    getAvailability(location: WonderlandTrailLocation): MutableMap<string, WonderlandTrailAvailabilityType>;
+    getDayAvailability(location: WonderlandTrailLocation, date: DateTime): SyncResult<WonderlandTrailAvailabilityType>;
+}
+declare class WonderlandTrailDirection {
+    private readonly value;
+    private constructor();
+    static readonly clockwise: WonderlandTrailDirection;
+    static readonly counterClockwise: WonderlandTrailDirection;
+    toString(): string;
+    reverse(): WonderlandTrailDirection;
+}
+declare class WonderlandTrailConnection {
+    readonly startLocation: WonderlandTrailLocation;
+    readonly endLocation: WonderlandTrailLocation;
+    readonly distanceMiles: number;
+    readonly ascentFeet: number;
+    readonly descentFeet: number;
+    readonly direction: WonderlandTrailDirection;
+    readonly intermediateLocations: Iterable$1<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>;
+    private static ensureExists;
+    private static ensureAllExist;
+    reverseDirection(): WonderlandTrailConnection;
+    join(connection: WonderlandTrailConnection): WonderlandTrailConnection;
+    containsLocation(location: WonderlandTrailLocation): boolean;
+    isLoop(): boolean;
+}
+declare class WonderlandTrailConnections {
+    private connections;
+    readonly addReverseConnectionDefault: boolean;
+    private constructor();
+    static create(addReverseConnectionDefault?: boolean): WonderlandTrailConnections;
+    static createDefault(): WonderlandTrailConnections;
+    iterateConnections(startLocation?: WonderlandTrailLocation, endLocation?: WonderlandTrailLocation, direction?: WonderlandTrailDirection): Iterator$1<WonderlandTrailConnection>;
+    iterateConnections(properties: {
+        startLocation?: WonderlandTrailLocation;
+        endLocation?: WonderlandTrailLocation;
+        direction?: WonderlandTrailDirection;
+    }): Iterator$1<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(properties: {
+        startLocation: WonderlandTrailLocation;
+        endLocation: WonderlandTrailLocation;
+        distanceMiles: number;
+        ascentFeet: number;
+        descentFeet: number;
+        direction?: WonderlandTrailDirection;
+        intermediateLocations?: Iterable$1<WonderlandTrailLocation>;
+        addReverseConnection?: boolean;
+    }): this;
+    containsConnection(connection: WonderlandTrailConnection): boolean;
+    reverseDirection(): WonderlandTrailConnections;
+    expandConnections(startLocation?: WonderlandTrailLocation, endLocation?: WonderlandTrailLocation, direction?: WonderlandTrailDirection): WonderlandTrailConnections;
+}
+declare class WonderlandTrailItinerary {
+    readonly startDay: DateTime;
+    private readonly connections;
+    private readonly availabilityTypes;
+    private constructor();
+    static create(startDay: DateTime): WonderlandTrailItinerary;
+    clone(): WonderlandTrailItinerary;
+    getConnections(): Iterable$1<WonderlandTrailConnection>;
+    getEndDay(): DateTime;
+    getDayCount(): number;
+    getStartLocation(): SyncResult<WonderlandTrailLocation>;
+    getIntermediateLocations(): Iterable$1<WonderlandTrailLocation>;
+    getEndLocation(): SyncResult<WonderlandTrailLocation>;
+    getPath(): Iterable$1<WonderlandTrailLocation>;
+    getPathStrings(includeAvailabilityTypes?: boolean): Iterable$1<string>;
+    contains(parameters: {
+        location: WonderlandTrailLocation;
+        checkItineraryStartLocation?: boolean;
+        checkItineraryIntermediateLocations?: boolean;
+        checkItineraryEndLocation?: boolean;
+    }): boolean;
+    containsAny(parameters: {
+        connection: WonderlandTrailConnection;
+        checkConnectionStartLocation?: boolean;
+        checkConnectionIntermediateLocations?: boolean;
+        checkConnectionEndLocation?: boolean;
+        checkItineraryStartLocation?: boolean;
+        checkItineraryIntermediateLocations?: boolean;
+        checkItineraryEndLocation?: boolean;
+    }): boolean;
+    addConnection(connection: WonderlandTrailConnection): this;
+    addConnections(connections: JavascriptIterable<WonderlandTrailConnection>): this;
+    addAvailabilityType(availabilityType: WonderlandTrailAvailabilityType): this;
+    addAvailabilityTypes(availabilityTypes: JavascriptIterable<WonderlandTrailAvailabilityType>): this;
+    toString(includeAvailabilityTypes?: boolean): string;
+}
+declare class WonderlandTrailClient implements HttpClient {
+    static readonly permitItineraryId: string;
+    private readonly httpClient;
+    private readonly recreationDotGovClient;
+    private constructor();
+    static create(httpClient: HttpClient): WonderlandTrailClient;
+    sendRequest(request: HttpOutgoingRequest): AsyncResult<HttpIncomingResponse>;
+    sendGetRequest(url: string): AsyncResult<HttpIncomingResponse>;
+    getAvailability(month: number, year: number, allowWalkupPermits: boolean, allowIndividualSites: boolean, allowGroupSites: boolean, earlyAccessPermitLotteryId?: string): PromiseAsyncResult<WonderlandTrailAvailability>;
+    getAvailability(options: {
+        month: number;
+        year: number;
+        allowWalkupPermits: boolean;
+        allowIndividualSites: boolean;
+        allowGroupSites: boolean;
+        earlyAccessPermitLotteryId?: string;
+    }): PromiseAsyncResult<WonderlandTrailAvailability>;
+    findItineraries(parameters: {
+        availability: WonderlandTrailAvailability;
+        startDate: DateTime;
+        startLocation: WonderlandTrailLocation;
+        endLocation: WonderlandTrailLocation;
+        direction: WonderlandTrailDirection;
+        maximumDayDistanceMiles?: number;
+        maximumItineraryDays?: number;
+        campsitesToAvoid?: JavascriptIterable<WonderlandTrailLocation>;
+    }): Iterable$1<WonderlandTrailItinerary>;
+    findItinerariesAsync(parameters: {
+        startDay: DateTime;
+        startLocation?: WonderlandTrailLocation;
+        endLocation?: WonderlandTrailLocation;
+        direction?: WonderlandTrailDirection;
+        maximumDayDistanceMiles?: number;
+        maximumItineraryDays?: number;
+        allowWalkupPermits?: boolean;
+        allowIndividualSites?: boolean;
+        allowGroupSites?: boolean;
+        campsitesToAvoid?: JavascriptIterable<WonderlandTrailLocation>;
+    }): PromiseAsyncResult<Iterable$1<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 };