@fgv/ts-utils 1.2.0-alpha.2 → 1.3.0

package/ts-utils.d.ts

@@ -0,0 +1,2451 @@
+/**
+ * Determines if an iterable collection of {@link Result | Result<T>} were all successful.
+ * @param results - The collection of {@link Result | Result<T>} to be tested.
+ * @returns Returns {@link Success} with `true` if all {@link Result | results} are successful.
+ * If any are unsuccessful, returns {@link Failure} with a concatenated summary the error
+ * messages from all failed elements.
+ * @public
+ */
+export declare function allSucceed<T>(results: Iterable<Result<unknown>>, successValue: T): Result<T>;
+
+/**
+ * A helper function to create a {@link Converter} which converts `unknown` to an array of `<T>`.
+ * @remarks
+ * If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot
+ * be converted.  If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.
+ * @param converter - {@link Converter} used to convert each item in the array.
+ * @param ignoreErrors - Specifies treatment of unconvertable elements.
+ * @returns A {@link Converter} which returns an array of `<T>`.
+ * @public
+ */
+declare function arrayOf<T, TC = undefined>(converter: Converter<T, TC>, onError?: OnError_2): Converter<T[], TC>;
+
+declare namespace Base {
+    export {
+        ValidatorFunc,
+        GenericValidatorConstructorParams,
+        GenericValidator
+    }
+}
+
+/**
+ * Base templated wrapper to simplify creation of new {@link Converter}s.
+ * @public
+ */
+export declare class BaseConverter<T, TC = undefined> implements Converter<T, TC> {
+    /**
+     * @internal
+     */
+    protected readonly _defaultContext?: TC;
+    /**
+     * @internal
+     */
+    protected _isOptional: boolean;
+    /**
+     * @internal
+     */
+    protected _brand?: string;
+    private readonly _converter;
+    /**
+     * Constructs a new {@link Converter} which uses the supplied function to perform the conversion.
+     * @param converter - The conversion function to be applied.
+     * @param defaultContext - Optional conversion context to be used by default.
+     * @param traits - Optional {@link ConverterTraits | traits} to be assigned to the resulting
+     * converter.
+     */
+    constructor(converter: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>, defaultContext?: TC, traits?: ConverterTraits);
+    /**
+     * {@inheritdoc Converter.isOptional}
+     */
+    get isOptional(): boolean;
+    /**
+     * {@inheritdoc Converter.brand}
+     */
+    get brand(): string | undefined;
+    /**
+     * {@inheritdoc Converter.convert}
+     */
+    convert(from: unknown, context?: TC): Result<T>;
+    /**
+     * {@inheritdoc Converter.convertOptional}
+     */
+    convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T | undefined>;
+    /**
+     * {@inheritdoc Converter.optional}
+     */
+    optional(onError?: OnError): Converter<T | undefined, TC>;
+    /**
+     * {@inheritdoc Converter.map}
+     */
+    map<T2>(mapper: (from: T) => Result<T2>): Converter<T2, TC>;
+    /**
+     * {@inheritdoc Converter.mapConvert}
+     */
+    mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC>;
+    /**
+     * {@inheritdoc Converter.mapItems}
+     */
+    mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC>;
+    /**
+     * {@inheritdoc Converter.mapConvertItems}
+     */
+    mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;
+    /**
+     * {@inheritdoc Converter.withTypeGuard}
+     */
+    withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI, TC>;
+    /**
+     * {@inheritdoc Converter.withItemTypeGuard}
+     */
+    withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI[], TC>;
+    /**
+     * {@inheritdoc Converter.withConstraint}
+     */
+    withConstraint(constraint: (val: T) => boolean | Result<T>, options?: ConstraintOptions): Converter<T, TC>;
+    /**
+     * {@inheritdoc Converter.withBrand}
+     */
+    withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC>;
+    /**
+     * @internal
+     */
+    protected _context(supplied?: TC): TC | undefined;
+    /**
+     * @internal
+     */
+    protected _traits(traits?: Partial<ConverterTraits>): ConverterTraits;
+    /**
+     * @internal
+     */
+    protected _with(traits: Partial<ConverterTraits>): this;
+}
+
+/**
+ * A {@link Converter} which converts `unknown` to `boolean`.
+ * @remarks
+ * Boolean values or the case-insensitive strings `'true'` and `'false'` succeed.
+ * Anything else fails.
+ * @public
+ */
+declare const boolean: BaseConverter<boolean, undefined>;
+
+/**
+ * A {@link Validation.Classes.BooleanValidator | BooleanValidator} which validates a boolean in place.
+ * @public
+ */
+declare const boolean_2: BooleanValidator<unknown>;
+
+/**
+ * An in-place {@link Validation.Validator | Validator} for `boolean` values.
+ * @public
+ */
+declare class BooleanValidator<TC = unknown> extends GenericValidator<boolean, TC> {
+    /**
+     * Constructs a new {@link Validation.Classes.BooleanValidator | BooleanValidator}.
+     * @param params - Optional {@link Validation.Classes.BooleanValidatorConstructorParams | init params} for the
+     * new {@link Validation.Classes.BooleanValidator | BooleanValidator}.
+     */
+    constructor(params?: BooleanValidatorConstructorParams<TC>);
+    /**
+     * Static method which validates that a supplied `unknown` value is a `boolean`.
+     * @param from - The `unknown` value to be tested.
+     * @returns Returns `true` if `from` is a `boolean`, or {@link Failure} with an error
+     * message if not.
+     */
+    static validateBoolean(from: unknown): boolean | Failure<boolean>;
+}
+
+/**
+ * Parameters used to construct a {@link Validation.Classes.BooleanValidator | BooleanValidator}.
+ * @public
+ */
+declare type BooleanValidatorConstructorParams<TC = unknown> = GenericValidatorConstructorParams<boolean, TC>;
+
+/**
+ * Helper type to brand a simple type to prevent inappropriate use
+ * @public
+ */
+export declare type Brand<T, B> = T & {
+    __brand: B;
+};
+
+/**
+ * Wraps a function which might throw to convert exception results
+ * to {@link Failure}.
+ * @param func - The function to be captured.
+ * @returns Returns {@link Success} with a value of type `<T>` on
+ * success , or {@link Failure} with the thrown error message if
+ * `func` throws an `Error`.
+ * @public
+ */
+export declare function captureResult<T>(func: () => T): Result<T>;
+
+declare namespace Classes {
+    export {
+        StringValidator,
+        StringValidatorConstructorParams,
+        BooleanValidator,
+        BooleanValidatorConstructorParams,
+        NumberValidator,
+        NumberValidatorConstructorParams,
+        FieldValidators,
+        ObjectValidator,
+        ObjectValidatorConstructorParams,
+        ObjectValidatorOptions
+    }
+}
+
+/**
+ * Computes an md5 hash from an array of strings. Not secure and not intended to be secure.
+ * @param parts - The strings to be hashed
+ * @returns An md5 hash of the parts
+ * @public
+ */
+declare function computeHash(parts: string[]): string;
+
+/**
+ * A {@link Validation.Constraint | Constraint<T>} function returns
+ * `true` if the supplied value meets the constraint. Can return
+ * {@link Failure} with an error message or simply return `false`
+ * for a default message.
+ * @public
+ */
+declare type Constraint<T> = (val: T) => boolean | Failure<T>;
+
+/**
+ * Options for {@link Converter.withConstraint}.
+ * @public
+ */
+export declare interface ConstraintOptions {
+    /**
+     * Optional description for error messages when constraint
+     * function returns false.
+     */
+    readonly description: string;
+}
+
+/**
+ * Union of all supported constraint traits.
+ * @public
+ */
+declare type ConstraintTrait = FunctionConstraintTrait;
+
+/**
+ * Deprecated name for Infer<T> retained for compatibility
+ * @deprecated use @see Infer instead
+ * @internal
+ */
+export declare type ConvertedToType<TCONV> = Infer<TCONV>;
+
+/**
+ * Generic converter to convert unknown to a templated type `<T>`, using
+ * intrinsic rules or as modified by an optional conversion context
+ * of optional templated type `<TC>` (default `undefined`).
+ * @public
+ */
+export declare interface Converter<T, TC = undefined> extends ConverterTraits {
+    /**
+     * Indicates whether this element is explicitly optional.
+     */
+    readonly isOptional: boolean;
+    /**
+     * Returns the brand for a branded type.
+     */
+    readonly brand?: string;
+    /**
+     * Converts from `unknown` to `<T>`.
+     * @param from - The `unknown` to be converted
+     * @param context - An optional conversion context of type `<TC>` to be used in
+     * the conversion.
+     * @returns A {@link Result} with a {@link Success} and a value on success or an
+     * {@link Failure} with a a message on failure.
+     */
+    convert(from: unknown, context?: TC): Result<T>;
+    /**
+     * Converts from `unknown` to `<T>` or `undefined`, as appropriate.
+     *
+     * @remarks
+     * If `onError` is `failOnError`, the converter succeeds for
+     * `undefined` or any convertible value, but reports an error
+     * if it encounters a value that cannot be converted.
+     *
+     * If `onError` is `ignoreErrors` (default) then values that
+     * cannot be converted result in a successful return of `undefined`.
+     * @param from - The `unknown` to be converted
+     * @param context - An optional conversion context of type `<TC>` to be used in
+     * the conversion.
+     * @param onError - Specifies handling of values that cannot be converted (default `ignoreErrors`).
+     * @returns A {@link Result} with a {@link Success} and a value on success or an
+     * {@link Failure} with a a message on failure.
+     */
+    convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T | undefined>;
+    /**
+     * Creates a {@link Converter} for an optional value.
+     *
+     * @remarks
+     * If `onError` is `failOnError`, the resulting converter will accept `undefined`
+     * or a convertible value, but report an error if it encounters a value that cannot be
+     * converted.
+     *
+     * If `onError` is `ignoreErrors` (default) then values that cannot be converted will
+     * result in a successful return of `undefined`.
+     *
+     * @param onError - Specifies handling of values that cannot be converted (default `ignoreErrors`).
+     * @returns A new {@link Converter} returning `<T|undefined>`.
+     * */
+    optional(onError?: OnError): Converter<T | undefined, TC>;
+    /**
+     * Creates a {@link Converter} which applies a (possibly) mapping conversion to
+     * the converted value of this {@link Converter}.
+     * @param mapper - A function which maps from the the result type `<T>` of this
+     * converter to a new result type `<T2>`.
+     * @returns A new {@link Converter} returning `<T2>`.
+     */
+    map<T2>(mapper: (from: T) => Result<T2>): Converter<T2, TC>;
+    /**
+     * Creates a {@link Converter} which applies an additional supplied
+     * converter to the result of this converter.
+     *
+     * @param mapConverter - The {@link Converter} to be applied to the
+     * converted result from this {@link Converter}.
+     * @returns A new {@link Converter} returning `<T2>`.
+     */
+    mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC>;
+    /**
+     * Creates a {@link Converter} which maps the individual items of a collection
+     * resulting from this {@link Converter} using the supplied map fuction.
+     *
+     * @remarks
+     * Fails if `from` is not an array.
+     *
+     * @param mapper - The map function to be applied to each element of the
+     * result of this {@link Converter}.
+     * @returns A new {@link Converter} returning `<TI[]>`.
+     */
+    mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC>;
+    /**
+     * Creates a {@link Converter} which maps the individual items of a collection
+     * resulting from this {@link Converter} using the supplied {@link Converter}.
+     *
+     * @remarks
+     * Fails if `from` is not an array.
+     *
+     * @param mapConverter - The {@link Converter} to be applied to each element of the
+     * result of this {@link Converter}.
+     * @returns A new {@link Converter} returning `<TI[]>`.
+     */
+    mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;
+    /**
+     * Creates a {@link Converter} which applies a supplied type guard to the conversion
+     * result.
+     * @param guard - The type guard function to apply.
+     * @param message - Optional message to be reported if the type guard fails.
+     * @returns A new {@link Converter} returning `<TI>`.
+     */
+    withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI, TC>;
+    /**
+     * Creates a {@link Converter} which applies a supplied type guard to each member of
+     * the conversion result from this converter.
+     *
+     * @remarks
+     * Fails if the conversion result is not an array or if any member fails the
+     * type guard.
+     * @param guard - The type guard function to apply to each element.
+     * @param message - Optional message to be reported if the type guard fails.
+     * @returns A new {@link Converter} returning `<TI>`.
+     */
+    withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string): Converter<TI[], TC>;
+    /**
+     * Creates a {@link Converter} which applies an optional constraint to the result
+     * of this conversion.  If this {@link Converter} (the base converter) succeeds, the new
+     * converter calls a supplied constraint evaluation function with the conversion, which
+     * fails the entire conversion if the constraint function returns either `false` or
+     * {@link Failure | Failure<T>}.
+     *
+     * @param constraint - Constraint evaluation function.
+     * @param options - {@link ConstraintOptions | Options} for constraint evaluation.
+     * @returns A new {@link Converter} returning `<T>`.
+     */
+    withConstraint(constraint: (val: T) => boolean | Result<T>, options?: ConstraintOptions): Converter<T, TC>;
+    /**
+     * returns a converter which adds a brand to the type to prevent mismatched usage
+     * of simple types.
+     * @param brand - The brand to be applied to the result value.
+     * @returns A {@link Converter} returning `Brand<T, B>`.
+     */
+    withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC>;
+}
+
+declare namespace Converters {
+    export {
+        templateString,
+        enumeratedValue,
+        mappedEnumeratedValue,
+        literal,
+        delimitedString,
+        oneOf,
+        arrayOf,
+        extendedArrayOf,
+        recordOf,
+        mapOf,
+        validateWith,
+        element,
+        optionalElement,
+        field,
+        optionalField,
+        object,
+        strictObject,
+        discriminatedObject,
+        transform,
+        rangeTypeOf,
+        rangeOf,
+        StringMatchOptions,
+        StringConverter,
+        string,
+        value,
+        number,
+        boolean,
+        optionalString,
+        isoDate,
+        optionalNumber,
+        optionalBoolean,
+        stringArray,
+        numberArray,
+        KeyedConverterOptions,
+        ObjectConverterOptions,
+        FieldConverters,
+        ObjectConverter,
+        StrictObjectConverterOptions,
+        DiscriminatedObjectConverters
+    }
+}
+export { Converters }
+
+/**
+ * Converter traits.
+ * @public
+ */
+export declare interface ConverterTraits {
+    readonly isOptional: boolean;
+    readonly brand?: string;
+}
+
+declare namespace Csv {
+    export {
+        readCsvFileSync
+    }
+}
+export { Csv }
+
+/**
+ * Default {@link RangeOfFormats | formats} to use for both
+ * open-ended and complete {@link RangeOf | RangeOf<T>}.
+ * @public
+ */
+export declare const DEFAULT_RANGEOF_FORMATS: {
+    minOnly: string;
+    maxOnly: string;
+    minMax: string;
+};
+
+/**
+ * Default {@link Validation.ValidatorTraitValues | validation traits}.
+ * @public
+ */
+declare const defaultValidatorTraits: ValidatorTraitValues;
+
+/**
+ * Helper function to create a {@link Converter} which converts any `string` into an
+ * array of `string`, by separating at a supplied delimiter.
+ * @remarks
+ * Delimeter may also be supplied as context at conversion time.
+ * @param delimiter - The delimiter at which to split.
+ * @returns A new {@link Converter} returning `string[]`.
+ * @public
+ */
+declare function delimitedString(delimiter: string, options?: 'filtered' | 'all'): Converter<string[], string>;
+
+/**
+ * A {@link DetailedFailure} extends {@link Failure} to report optional failure details in
+ * addition to the error message.
+ * @public
+ */
+export declare class DetailedFailure<T, TD> extends Failure<T> {
+    /**
+     * @internal
+     */
+    protected _detail: TD;
+    /**
+     * Constructs a new {@link DetailedFailure | DetailedFailure<T, TD>} with the supplied
+     * message and detail.
+     * @param message - The message to be returned.
+     * @param detail - The error detail to be returned.
+     */
+    constructor(message: string, detail: TD);
+    /**
+     * The error detail associated with this {@link DetailedFailure}.
+     */
+    get detail(): TD;
+    /**
+     * Reports that this {@link DetailedFailure} is a failure.
+     * @remarks
+     * Always true for {@link DetailedFailure} but can be used as type guard
+     * to discriminate {@link DetailedSuccess} from {@link DetailedFailure} in
+     * a {@link DetailedResult}.
+     * @returns `true`
+     */
+    isFailure(): this is DetailedFailure<T, TD>;
+    /**
+     * Propagates the error message and detail from this result.
+     * @remarks
+     * Mutates the success type as the success callback would have, but does not
+     * call the success callback.
+     * @param _cb - {@link DetailedSuccessContinuation | Success callback} to be called
+     * on a {@link DetailedResult} in case of success (ignored).
+     * @returns A new {@link DetailedFailure | DetailedFailure<TN, TD>} which contains
+     * the error message and detail from this one.
+     */
+    onSuccess<TN>(_cb: DetailedSuccessContinuation<T, TD, TN>): DetailedResult<TN, TD>;
+    /**
+     * Invokes the supplied {@link DetailedFailureContinuation | failure callback} and propagates
+     * its returned {@link DetailedResult | DetailedResult<T, TD>}.
+     * @param cb - The {@link DetailedFailureContinuation | failure callback} to be invoked.
+     * @returns The {@link DetailedResult | DetailedResult<T, TD>} returned by the failure callback.
+     */
+    onFailure(cb: DetailedFailureContinuation<T, TD>): DetailedResult<T, TD>;
+}
+
+/**
+ * Callback to be called when a {@link DetailedResult} encounters a failure.
+ * @remarks
+ * A failure callback can change {@link Failure} to {@link Success} (e.g. by returning a default value)
+ * or it can change or embellish the error message, but it cannot change the success return type.
+ * @public
+ */
+export declare type DetailedFailureContinuation<T, TD> = (message: string, detail: TD) => DetailedResult<T, TD>;
+
+/**
+ * Type inference to determine the result type `T` of a {@link DetailedResult | DetailedResult<T, TD>}.
+ * @beta
+ */
+export declare type DetailedResult<T, TD> = DetailedSuccess<T, TD> | DetailedFailure<T, TD>;
+
+/**
+ * A {@link DetailedSuccess} extends {@link Success} to report optional success details in
+ * addition to the error message.
+ * @public
+ */
+export declare class DetailedSuccess<T, TD> extends Success<T> {
+    /**
+     * @internal
+     */
+    protected _detail?: TD;
+    /**
+     * Constructs a new {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied
+     * value and detail.
+     * @param value - The value to be returned.
+     * @param detail - An optional successful detail to be returned.  If omitted, detail
+     * will be `undefined`.
+     */
+    constructor(value: T, detail?: TD);
+    /**
+     * The success detail associated with this {@link DetailedSuccess}, or `undefined` if
+     * no detail was supplied.
+     */
+    get detail(): TD | undefined;
+    /**
+     * Reports that this {@link DetailedSuccess} is a success.
+     * @remarks
+     * Always true for {@link DetailedSuccess} but can be used as type guard
+     * to discriminate {@link DetailedSuccess} from {@link DetailedFailure} in
+     * a {@link DetailedResult}.
+     * @returns `true`
+     */
+    isSuccess(): this is DetailedSuccess<T, TD>;
+    /**
+     * Invokes the supplied {@link DetailedSuccessContinuation | success callback} and propagates
+     * its returned {@link DetailedResult | DetailedResult<TN, TD>}.
+     * @remarks
+     * The success callback mutates the return type from `<T>` to `<TN>`.
+     * @param cb - The {@link DetailedSuccessContinuation | success callback} to be invoked.
+     * @returns The {@link DetailedResult | DetailedResult<T, TD>} returned by the success callback.
+     */
+    onSuccess<TN>(cb: DetailedSuccessContinuation<T, TD, TN>): DetailedResult<TN, TD>;
+    /**
+     * Propagates this {@link DetailedSuccess}.
+     * @remarks
+     * Failure does not mutate return type so we can return this event directly.
+     * @param _cb - {@link DetailedFailureContinuation | Failure callback} to be called
+     * on a {@link DetailedResult} in case of failure (ignored).
+     * @returns `this`
+     */
+    onFailure(_cb: DetailedFailureContinuation<T, TD>): DetailedResult<T, TD>;
+}
+
+/**
+ * Callback to be called when a {@link DetailedResult} encounters success.
+ * @remarks
+ * A success callback can return a different result type than it receives, allowing
+ * success results to chain through intermediate result types.
+ * @public
+ */
+export declare type DetailedSuccessContinuation<T, TD, TN> = (value: T, detail?: TD) => DetailedResult<TN, TD>;
+
+/**
+ * Helper to create a {@link Converter} whhich converts a discriminated object without changing shape.
+ * @remarks
+ * Takes the name of the discriminator property and a
+ * {@link Converters.DiscriminatedObjectConverters | string-keyed Record of converters}. During conversion,
+ * the resulting {@link Converter} invokes the converter from `converters` that corresponds to the value of
+ * the discriminator property in the source object.
+ *
+ * If the source is not an object, the discriminator property is missing, or the discriminator has
+ * a value not present in the converters, conversion fails and returns {@link Failure} with more information.
+ * @param discriminatorProp - Name of the property used to discriminate types.
+ * @param converters - {@link Converters.DiscriminatedObjectConverters | String-keyed record of converters} to
+ * invoke, where each key corresponds to a value of the discriminator property.
+ * @returns A {@link Converter} which converts the corresponding discriminated object.
+ * @public
+ */
+declare function discriminatedObject<T, TD extends string = string, TC = unknown>(discriminatorProp: string, converters: DiscriminatedObjectConverters<T, TD>): Converter<T, TC>;
+
+/**
+ * A string-keyed `Record<string, Converter>` which maps specific {@link Converter | converters} to the
+ * value of a discriminator property.
+ * @public
+ */
+declare type DiscriminatedObjectConverters<T, TD extends string = string, TC = unknown> = Record<TD, Converter<T, TC>>;
+
+/**
+ * A helper function to create a {@link Converter} which extracts and converts an element from an array.
+ * @remarks
+ * The returned {@link Converter} returns {@link Success} with the converted value if the element exists
+ * in the supplied array and can be converted. Returns {@link Failure} with an error message otherwise.
+ * @param index - The index of the element to be extracted.
+ * @param converter - A {@link Converter} used to convert the extracted element.
+ * @returns A {@link Converter | Converter<T>} which extracts the specified element from an array.
+ * @public
+ */
+declare function element<T, TC = undefined>(index: number, converter: Converter<T, TC>): Converter<T, TC>;
+
+/**
+ * Helper function to create a {@link Converter} which converts `unknown` to one of a set of supplied
+ * enumerated values. Anything else fails.
+ *
+ * @remarks
+ * Allowed enumerated values can also be supplied as context at conversion time.
+ * @param values - Array of allowed values.
+ * @returns A new {@link Converter} returning `<T>`.
+ * @public
+ */
+declare function enumeratedValue<T>(values: T[]): Converter<T, T[]>;
+
+/**
+ * An experimental array template which extend built-in `Array` to include a handful
+ * of predicates which return {@link Result | Result<T>}.
+ * @beta
+ */
+export declare class ExtendedArray<T> extends Array<T> {
+    readonly itemDescription: string;
+    /**
+     * Constructs an {@link ExtendedArray}.
+     * @param itemDescription - Brief description of the type of each item in this array.
+     * @param items - The initial contents of the array.
+     */
+    constructor(itemDescription: string, ...items: T[]);
+    /**
+     * Type guard to determine if some arbitrary array is an
+     * {@link ExtendedArray}
+     * @param a - The `Array` to be tested.
+     * @returns Returns `true` if `a` is an {@link ExtendedArray},
+     * `false` otherwise.
+     */
+    static isExtendedArray<T>(a?: T[]): a is ExtendedArray<T>;
+    /**
+     * Determines if this array contains exactly one element which matches
+     * a supplied predicate.
+     * @param predicate - The predicate function to be applied.
+     * @returns Returns {@link Success | Success<T>} with the single matching
+     * result if exactly one item matches `predicate`.  Returns {@link Failure}
+     * with an error message if there are no matches or more than one match.
+     */
+    single(predicate?: (item: T) => boolean): Result<T>;
+    /**
+     * Returns the first element of an {@link ExtendedArray}. Fails with an
+     * error message if the array is empty.
+     * @param failMessage - Optional message to be displayed in the event of failure.
+     * @returns Returns {@link Success | Success<T>} with the value of the first element
+     * in the array, or {@link Failure} with an error message if the array is empty.
+     */
+    first(failMessage?: string): Result<T>;
+    /**
+     * Returns an array containing all elements of an {@link ExtendedArray}. Fails with
+     * an error message if the array is empty.
+     * @param failMessage - Optional message to be displayed in the event of failure.
+     * @returns Returns {@link Success | Success<T[]>} with a new (non-extended) `Array`
+     * containing the elements of this array, or {@link Failure} with an error message
+     * if the array is empty.
+     */
+    atLeastOne(failMessage?: string): Result<T[]>;
+    /**
+     * Gets a new (non-extended) `Array` containing all of the elements from this
+     * {@link ExtendedArray}.
+     * @returns A new (non-extended) `Array<T>`.
+     */
+    all(): T[];
+}
+
+/**
+ * A helper function to create a {@link Converter} which converts `unknown` to {@link ExtendedArray | ExtendedArray<T>}.
+ * @remarks
+ * If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot
+ * be converted.  If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.
+ * @param converter - {@link Converter} used to convert each item in the array
+ * @param ignoreErrors - Specifies treatment of unconvertable elements
+ * @beta
+ */
+declare function extendedArrayOf<T, TC = undefined>(label: string, converter: Converter<T, TC>, onError?: OnError_2): Converter<ExtendedArray<T>, TC>;
+
+/**
+ * Returns {@link Failure | Failure<T>} with the supplied error message.
+ * @param message - Error message to be returned.
+ * @public
+ */
+declare function fail_2<T>(message: string): Failure<T>;
+export { fail_2 as fail }
+
+/**
+ * Reports a failed {@link IResult | result} from some operation, with an error message.
+ * @public
+ */
+export declare class Failure<T> implements IResult<T> {
+    /**
+     * {@inheritdoc IResult.success}
+     */
+    readonly success = false;
+    /**
+     * @internal
+     */
+    private readonly _message;
+    /**
+     * Constructs a {@link Failure} with the supplied message.
+     * @param message - Error message to be reported.
+     */
+    constructor(message: string);
+    /**
+     * Gets the error message associated with this error.
+     */
+    get message(): string;
+    /**
+     * {@inheritdoc IResult.isSuccess}
+     */
+    isSuccess(): this is Success<T>;
+    /**
+     * {@inheritdoc IResult.isFailure}
+     */
+    isFailure(): this is Failure<T>;
+    /**
+     * {@inheritdoc IResult.getValueOrThrow}
+     */
+    getValueOrThrow(logger?: IResultLogger): never;
+    /**
+     * {@inheritdoc IResult.getValueOrDefault}
+     */
+    getValueOrDefault(dflt?: T): T | undefined;
+    /**
+     * {@inheritdoc IResult.onSuccess}
+     */
+    onSuccess<TN>(_: SuccessContinuation<T, TN>): Result<TN>;
+    /**
+     * {@inheritdoc IResult.onFailure}
+     */
+    onFailure(cb: FailureContinuation<T>): Result<T>;
+    /**
+     * {@inheritdoc IResult.withFailureDetail}
+     */
+    withFailureDetail<TD>(detail: TD): DetailedResult<T, TD>;
+    /**
+     * {@inheritdoc IResult.withDetail}
+     */
+    withDetail<TD>(detail: TD, _successDetail?: TD): DetailedResult<T, TD>;
+    /**
+     * Get a 'friendly' string representation of this object.
+     * @remarks
+     * The string representation of a {@link Failure} value is the error message.
+     * @returns A string representing this object.
+     */
+    toString(): string;
+}
+
+/**
+ * Continuation callback to be called in the event that an
+ * {@link Result} fails.
+ * @public
+ */
+export declare type FailureContinuation<T> = (message: string) => Result<T>;
+
+/**
+ * Returns {@link DetailedFailure | DetailedFailure<T, TD>} with a supplied error message and detail.
+ * @param message - The error message to be returned.
+ * @param detail - The event detail to be returned.
+ * @returns An {@link DetailedFailure | DetailedFailure<T, TD>} with the supplied error
+ * message and detail.
+ * @public
+ */
+export declare function failWithDetail<T, TD>(message: string, detail: TD): DetailedFailure<T, TD>;
+
+/**
+ * A helper function to create a {@link Converter} which extracts and convert a property specified
+ * by name from an object.
+ * @remarks
+ * The resulting {@link Converter} returns {@link Success} with the converted value of the correpsonding
+ * object property if the field exists and can be converted. Returns {@link Failure} with an error message
+ * otherwise.
+ * @param name - The name of the field to be extracted.
+ * @param converter - {@link Converter} used to convert the extracted field.
+ * @public
+ */
+declare function field<T, TC = undefined>(name: string, converter: Converter<T, TC>): Converter<T, TC>;
+
+/**
+ * Per-property converters for each of the properties in type T.
+ * @remarks
+ * Used to construct a {@link Converters.ObjectConverter | ObjectConverter}
+ * @public
+ */
+declare type FieldConverters<T, TC = unknown> = {
+    [key in keyof T]: Converter<T[key], TC>;
+};
+
+/**
+ * String-keyed record of initialization functions to be passed to {@link populateObject}.
+ * @public
+ */
+export declare type FieldInitializers<T> = {
+    [key in keyof T]: (state: Partial<T>) => Result<T[key]>;
+};
+
+/**
+ * Per-property {@link Validation.Validator | validators} for each of the properties in `<T>`.
+ * @public
+ */
+declare type FieldValidators<T, TC = unknown> = {
+    [key in keyof T]: Validator<T[key], TC>;
+};
+
+/**
+ * Formats a list of items using the supplied template and formatter, one result
+ * per output line.
+ * @param format - A mustache template used to format each item.
+ * @param items - The items to be formatted.
+ * @param itemFormatter - The {@link Formatter | Formatter<T>} used to format each item.
+ * @returns The resulting string.
+ * @beta
+ */
+export declare function formatList<T>(format: string, items: T[], itemFormatter: Formatter<T>): Result<string>;
+
+/**
+ * Interface for an object that can be formatted.
+ * @beta
+ */
+export declare interface Formattable {
+    /**
+     * Formats an object using the supplied mustache template.
+     * @param format - A mustache template used to format the object.
+     * @returns {@link Success} with the resulting string, or {@link Failure}
+         * with an error message if an error occurs.
+         */
+     format(format: string): Result<string>;
+    }
+
+    /**
+     * Base class which adds common formatting.
+     * @beta
+     */
+    export declare class FormattableBase {
+        /**
+         * Helper enables derived classes to add named details to a formatted presentation.
+         * @param details - An array of detail description strings.
+         * @param label - Label to use for the new detail.
+         * @param value - Value to use for the new detail.
+         * @internal
+         */
+        protected static _tryAddDetail(details: string[], label: string, value: string | undefined): void;
+        /**
+         * {@inheritdoc Formattable.format}
+         */
+        format(template: string): Result<string>;
+    }
+
+    /**
+     * Destination format for some formatted string.
+     * @beta
+     */
+    export declare type FormatTargets = 'text' | 'markdown' | 'embed';
+
+    /**
+     * Type definition for a formatting function, which takes a `string` and an
+     * item and returns {@link Result | Result<string>}.
+     * @beta
+     */
+    export declare type Formatter<T> = (format: string, item: T) => Result<string>;
+
+    /**
+     * A collection of {@link Formatter | formatters} indexed by target name, to enable
+     * different format methods per output target.
+     * @beta
+     */
+    export declare type FormattersByExtendedTarget<TFT extends FormatTargets, T> = Record<TFT, Formatter<T>>;
+
+    /**
+     * A collection of {@link Formatter | formatters} indexed by the {@link FormatTargets | default supported
+     * target formats}.
+     * @beta
+     */
+    export declare type FormattersByTarget<T> = FormattersByExtendedTarget<FormatTargets, T>;
+
+    /**
+     * A {@link Validation.ConstraintTrait | ConstraintTrait} indicating that
+     * a {@link Validation.Constraint | Constraint<T>} function provides an
+     * additional constraint implementation.
+     * @public
+     */
+    declare interface FunctionConstraintTrait {
+        type: 'function';
+    }
+
+    /**
+     * Generic base implementation for an in-place {@link Validation.Validator | Validator}.
+     * @public
+     */
+    declare class GenericValidator<T, TC = undefined> implements Validator<T, TC> {
+        /**
+         * {@inheritdoc Validation.Validator.traits}
+         */
+        readonly traits: ValidatorTraits;
+        /**
+         * @internal
+         */
+        protected readonly _validator: ValidatorFunc<T, TC>;
+        /**
+         * @internal
+         */
+        protected readonly _options: ValidatorOptions<TC>;
+        /**
+         * Constructs a new {@link Validation.Base.GenericValidator | GenericValidator<T>}.
+         * @param params - The {@link Validation.Base.GenericValidatorConstructorParams | constructor params}
+         * used to configure validation.
+         */
+        constructor(params: Partial<GenericValidatorConstructorParams<T, TC>>);
+        /**
+         * {@inheritdoc Validation.Validator.isOptional}
+         */
+        get isOptional(): boolean;
+        /**
+         * {@inheritdoc Validation.Validator.brand}
+         */
+        get brand(): string | undefined;
+        /**
+         * {@inheritdoc Validation.Validator.validate}
+         */
+        validate(from: unknown, context?: TC): Result<T>;
+        /**
+         * {@inheritdoc Validation.Validator.validateOptional}
+         */
+        validateOptional(from: unknown, context?: TC): Result<T | undefined>;
+        /**
+         * {@inheritdoc Validation.Validator.guard}
+         */
+        guard(from: unknown, context?: TC): from is T;
+        /**
+         * {@inheritdoc Validation.Validator.optional}
+         */
+        optional(): Validator<T | undefined, TC>;
+        /**
+         * {@inheritdoc Validation.Validator.withConstraint}
+         */
+        withConstraint(constraint: Constraint<T>, trait?: ConstraintTrait): Validator<T, TC>;
+        /**
+         * {@inheritdoc Validation.Validator.brand}
+         */
+        withBrand<B extends string>(brand: B): Validator<Brand<T, B>, TC>;
+        /**
+         * Gets a default or explicit context.
+         * @param explicitContext - Optional explicit context.
+         * @returns The appropriate context to use.
+         * @internal
+         */
+        protected _context(explicitContext?: TC): TC | undefined;
+    }
+
+    /**
+     * Options used to initialize a {@link Validation.Base.GenericValidator | GenericValidator}.
+     * @public
+     */
+    declare interface GenericValidatorConstructorParams<T, TC> {
+        options?: ValidatorOptions<TC>;
+        traits?: Partial<ValidatorTraits>;
+        validator?: ValidatorFunc<T, TC>;
+    }
+
+    declare namespace Hash {
+        export {
+            computeHash,
+            Normalizer
+        }
+    }
+    export { Hash }
+
+    /**
+     * Infers the type that will be returned by an intstantiated converter.  Works
+     * for complex as well as simple types.
+     * @example `Infer<typeof Converters.mapOf(Converters.stringArray)>` is `Map<string, string[]>`
+     * @beta
+     */
+    export declare type Infer<TCONV> = TCONV extends Converter<infer TTO> ? InnerInferredType<TTO> : never;
+
+    /**
+     * internal
+     */
+    declare type InnerInferredType<TCONV> = TCONV extends Converter<infer TTO> ? (TTO extends Array<infer TTOELEM> ? InnerInferredType<TTOELEM>[] : TTO) : (TCONV extends Array<infer TELEM> ? InnerInferredType<TELEM>[] : TCONV);
+
+    /**
+     * Represents the result of some operation of sequence of operations.
+     * @remarks
+     * This common contract enables comingled discriminated usage of {@link Success | Success<T>}
+     * and {@link Failure | Failure<T>}.
+     * @public
+     */
+    export declare interface IResult<T> {
+        /**
+         * Indicates whether the operation was successful.
+         */
+        readonly success: boolean;
+        /**
+         * Indicates whether this operation was successful.  Functions
+         * as a type guard for {@link Success | Success<T>}.
+         */
+        isSuccess(): this is Success<T>;
+        /**
+         * Indicates whether this operation failed.  Functions
+         * as a type guard for {@link Failure | Failure<T>}.
+         */
+        isFailure(): this is Failure<T>;
+        /**
+         * Gets the value associated with a successful {@link IResult | result},
+         * or throws the error message if the corresponding operation failed.
+         * @param logger - An optional {@link IResultLogger | logger} to which the
+         * error will also be reported.
+         * @returns The return value, if the operation was successful.
+         * @throws The error message if the operation failed.
+         */
+        getValueOrThrow(logger?: IResultLogger): T;
+        /**
+         * Gets the value associated with a successful {@link IResult | result},
+         * or a default value if the corresponding operation failed.
+         * @param dflt - The value to be returned if the operation failed (default is
+         * `undefined`).
+         * @returns The return value, if the operation was successful.  Returns
+         * the supplied default value or `undefined` if no default is supplied.
+         */
+        getValueOrDefault(dflt?: T): T | undefined;
+        /**
+         * Calls a supplied {@link SuccessContinuation | success continuation} if
+         * the operation was a success.
+         * @remarks
+         * The {@link SuccessContinuation | success continuation} might return a
+         * different result type than {@link IResult} on which it is invoked. This
+         * enables chaining of operations with heterogenous return types.
+         *
+         * @param cb - The {@link SuccessContinuation | success continuation} to
+         * be called in the event of success.
+         * @returns If this operation was successful, returns the value returned
+         * by the {@link SuccessContinuation | success continuation}.  If this result
+         * failed, propagates the error message from this failure.
+         */
+        onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN>;
+        /**
+         * Calls a supplied {@link FailureContinuation | failed continuation} if
+         * the operation failed.
+         * @param cb - The {@link FailureContinuation | failure continuation} to
+         * be called in the event of failure.
+         * @returns If this operation failed, returns the value returned by the
+         * {@link FailureContinuation | failure continuation}.  If this result
+         * was successful, propagates the result value from the successful event.
+         */
+        onFailure(cb: FailureContinuation<T>): Result<T>;
+        /**
+         * Converts a {@link IResult | IResult<T>} to a {@link DetailedResult | DetailedResult<T, TD>},
+         * adding a supplied detail if the operation failed.
+         * @param detail - The detail to be added if this operation failed.
+         * @returns A new {@link DetailedResult | DetailedResult<T, TD>} with either
+         * the success result or the error message from this {@link IResult}, with
+         * the supplied detail (if this event failed) or detail `undefined` (if
+         * this result succeeded).
+         */
+        withFailureDetail<TD>(detail: TD): DetailedResult<T, TD>;
+        /**
+         * Converts a {@link IResult | IResult<T>} to a {@link DetailedResult | DetailedResult<T, TD>},
+         * adding supplied details.
+         * @param detail - The default detail to be added to the new {@link DetailedResult}.
+         * @param successDetail - An optional detail to be added if this result was successful.
+         * @returns A new {@link DetailedResult | DetailedResult<T, TD>} with either
+         * the success result or the error message from this {@link IResult} and the
+         * appopriate added detail.
+         */
+        withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;
+    }
+
+    /**
+     * Simple logger interface used by {@link IResult.getValueOrThrow}.
+     * @public
+     */
+    export declare interface IResultLogger {
+        /**
+         * Log an error message.
+         * @param message - The message to be logged.
+         */
+        error(message: string): void;
+    }
+
+    /**
+     * Helper type-guard function to report whether a specified key is present in
+     * a supplied object.
+     * @param key - The key to be tested.
+     * @param item - The object to be tested.
+     * @returns Returns `true` if the key is present, `false` otherwise.
+     * @public
+     */
+    export declare function isKeyOf<T extends object>(key: string | number | symbol, item: T): key is keyof T;
+
+    /**
+     * A {@link Converter} which converts an iso formatted string, a number or a `Date` object to
+     * a `Date` object.
+     * @public
+     */
+    declare const isoDate: BaseConverter<Date, undefined>;
+
+    /**
+     * Options for {@link Converters.(recordOf:withOptions)} and {@link Converters.(mapOf:withOptions)}
+     * helper functions.
+     * @public
+     */
+    declare interface KeyedConverterOptions<T extends string = string, TC = undefined> {
+        /**
+         * if `onError` is `'fail'` (default), then the entire conversion fails if any key or element
+         * cannot be converted.  If `onError` is `'ignore'`, failing elements are silently ignored.
+         */
+        onError?: 'fail' | 'ignore';
+        /**
+         * If present, `keyConverter` is used to convert the source object property names to
+         * keys in the resulting map or record.
+         * @remarks
+         * Can be used to coerce key names to supported values and/or strong types.
+         */
+        keyConverter?: Converter<T, TC>;
+    }
+
+    /**
+     * Type for factory methods which convert a key-value pair to a new unique value.
+     * @public
+     */
+    declare type KeyedThingFactory<TS, TD, TK extends string = string> = (key: TK, thing: TS) => Result<TD>;
+
+    /**
+     * Helper function to create a {@link Converter} which converts `unknown` to some supplied literal value. Succeeds with
+     * the supplied value if an identity comparison succeeds, fails otherwise.
+     * @param value - The value to be compared.
+     * @returns A {@link Converter} which returns the supplied value on success.
+     * @public
+     */
+    declare function literal<T>(value: T): Converter<T, unknown>;
+
+    /**
+     * Aggregates sucessful results from a collection of {@link DetailedResult | DetailedResult<T, TD>},
+     * optionally ignoring certain error details.
+     * @param results - The collection of {@link DetailedResult | DetailedResult<T, TD>} to be mapped.
+     * @param ignore - An array of error detail values (of type `<TD>`) that should be ignored.
+     * @returns {@link Success} with an array containing all successful results if all results either
+         * suceeded or returned error details listed in `ignore`.  If any results failed with details
+         * that cannot be ignored, returns {@link Failure} with an concatenated summary of all non-ignorable
+         * error mesasges.
+         * @public
+         */
+     export declare function mapDetailedResults<T, TD>(results: Iterable<DetailedResult<T, TD>>, ignore: TD[]): Result<T[]>;
+
+     /**
+      * Aggregates error messages from a collection of {@link Result | Result<T>}.
+      * @param results - An interable collection of {@link Result | Result<T>} for which
+      * error messages are aggregated.
+      * @returns An array of strings consisting of all error messages returned by
+      * {@link Result | results} in the source collection. Ignores {@link Success}
+      * results and returns an empty array if there were no errors.
+      * @public
+      */
+     export declare function mapFailures<T>(results: Iterable<Result<T>>): string[];
+
+     /**
+      * A helper function to create a {@link Converter} which converts the `string`-keyed properties
+      * using a supplied {@link Converter | Converter<T>} to produce a `Map<string, T>`.
+      * @remarks
+      * The resulting converter fails conversion if any element cannot be converted.
+      * @param converter - {@link Converter} used to convert each item in the source object.
+      * @returns A {@link Converter} which returns `Map<string, T>`.
+      * {@label default}
+      * @public
+      */
+     declare function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>): Converter<Map<TK, T>, TC>;
+
+     /**
+      * A helper function to create a {@link Converter} which converts the `string`-keyed properties
+      * using a supplied {@link Converter | Converter<T>} to produce a `Map<string, T>` and optionally
+      * specified handling of elements that cannot be converted.
+      * @remarks
+      * if `onError` is `'fail'` (default), then the entire conversion fails if any key or element
+      * cannot be converted.  If `onError` is `'ignore'`, failing elements are silently ignored.
+      * @param converter - {@link Converter} used to convert each item in the source object.
+      * @returns A {@link Converter} which returns `Map<string, T>`.
+      * {@label withOnError}
+      * @public
+      */
+     declare function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, onError: 'fail' | 'ignore'): Converter<Map<TK, T>, TC>;
+
+     /**
+      * A helper function to create a {@link Converter} which converts the `string`-keyed properties
+      * using a supplied {@link Converter | Converter<T>} to produce a `Map<TK, T>`.
+      * @remarks
+      * If present, the supplied {@link Converters.KeyedConverterOptions | options} can provide a strongly-typed
+      * converter for keys and/or control the handling of elements that fail conversion.
+      * @param converter - {@link Converter} used to convert each item in the source object.
+      * @param options - Optional {@link Converters.KeyedConverterOptions | KeyedConverterOptions<TK, TC>} which
+      * supplies a key converter and/or error-handling options.
+      * @returns A {@link Converter} which returns `Map<TK, T>`.
+      * {@label withOptions}
+      * @public
+      */
+     declare function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, options: KeyedConverterOptions<TK, TC>): Converter<Map<TK, T>, TC>;
+
+     /**
+      * Helper function to create a {@link Converter} which converts `unknown` to one of a set of supplied enumerated
+      * values, mapping any of multiple supplied values to the enumeration.
+      * @remarks
+      * Enables mapping of multiple input values to a consistent internal representation (so e.g. `'y'`, `'yes'`,
+      * `'true'`, `1` and `true` can all map to boolean `true`)
+      * @param map - An array of tuples describing the mapping. The first element of each tuple is the result
+      * value, the second is the set of values that map to the result.  Tuples are evaluated in the order
+      * supplied and are not checked for duplicates.
+      * @param message - An optional error message.
+      * @returns A {@link Converter} which applies the mapping and yields `<T>` on success.
+      * @public
+      */
+     declare function mappedEnumeratedValue<T>(map: [T, unknown[]][], message?: string): Converter<T, undefined>;
+
+     /**
+      * Aggregates sucessful result values from a collection of {@link Result | Result<T>}.
+      * @param results - The collection of {@link Result | Result<T>} to be mapped.
+      * @returns  If all {@link Result | results} are successful, returns {@link Success} with an
+      * array containing all returned values.  If any {@link Result | results} failed, returns
+      * {@link Failure} with a concatenated summary of all error messages.
+      * @public
+      */
+     export declare function mapResults<T>(results: Iterable<Result<T>>): Result<T[]>;
+
+     /**
+      * Aggregates successful results from a a collection of {@link Result | Result<T>}.
+      * @param results - An `Iterable` of {@link Result | Result<T>} from which success
+      * results are to be aggregated.
+      * @returns {@link Success} with an array of `<T>` if any results were successful. If
+          * all {@link Result | results} failed, returns {@link Failure} with a concatenated
+          * summary of all error messages.
+          * @public
+          */
+      export declare function mapSuccess<T>(results: Iterable<Result<T>>): Result<T[]>;
+
+      /**
+       * Applies a factory method to convert a `Map<TK, TS>` into a `Record<TK, TD>`.
+       * @param src - The `Map` object to be converted.
+       * @param factory - The factory method used to convert elements.
+       * @returns {@link Success} with the resulting `Record<TK, TD>` if conversion succeeds, or
+           * {@link Failure} with an error message if an error occurs.
+           * @public
+           */
+       export declare function mapToRecord<TS, TD, TK extends string = string>(src: Map<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
+
+       /**
+        * Computes a normalized hash for an arbitrary javascript value.
+        * @public
+        */
+       declare class Normalizer {
+           /**
+            * Computes a normalized md5 hash from an arbitrary supplied object.  Not secure and not
+            * intended to be secure.  Also not fast and not intended to be fast.
+            *
+            * Normalization just sorts Maps, Sets and object keys by hash so that differences in order
+            * do not affect the hash.
+            *
+            * @param from - The arbitrary `unknown` to be hashed.
+            * @returns A normalized md5 hash for the supplied value.
+            */
+           computeHash(from: unknown): Result<string>;
+           /**
+            * Compares two property names from some object being normalized.
+            * @param k1 - First key to be compared.
+            * @param k2 - Second key to be compared.
+            * @returns `1` if `k1` is greater, `-1` if `k2` is greater and
+            * `0` if they are equal.
+            * @internal
+            */
+           protected _compareKeys(k1: unknown, k2: unknown): number;
+           /**
+            * Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).
+            * @remarks
+            * Converts property names (entry key) to string and then sorts as string.
+            * @param entries - The entries to be normalized.
+            * @returns A normalized sorted array of entries.
+            * @internal
+            */
+           protected _normalizeEntries(entries: Iterable<[unknown, unknown]>): [unknown, unknown][];
+           /**
+            * Constructs a normalized string representation of some literal value.
+            * @param from - The literal value to be normalized.
+            * @returns A normalized string representation of the literal.
+            * @internal
+            */
+           protected _normalizeLiteral(from: string | number | bigint | boolean | symbol | undefined | Date | RegExp | null): Result<string>;
+       }
+
+       /**
+        * A {@link Converter} which converts `unknown` to a `number`.
+        * @remarks
+        * Numbers and strings with a numeric format succeed. Anything else fails.
+        * @public
+        */
+       declare const number: BaseConverter<number, undefined>;
+
+       /**
+        * A {@link Validation.Classes.NumberValidator | NumberValidator} which validates a number in place.
+        * @public
+        */
+       declare const number_2: NumberValidator<number, unknown>;
+
+       /**
+        * {@link Converter} to convert an `unknown` to an array of `number`.
+        * @remarks
+        * Returns {@link Success} with the the supplied value if it as an array
+        * of numbers, returns {@link Failure} with an error message otherwise.
+        * @public
+        */
+       declare const numberArray: Converter<number[], undefined>;
+
+       /**
+        * An in-place {@link Validation.Validator | Validator} for `number` values.
+        * @public
+        */
+       declare class NumberValidator<T extends number = number, TC = unknown> extends GenericValidator<T, TC> {
+           /**
+            * Constructs a new {@link Validation.Classes.NumberValidator | NumberValidator}.
+            * @param params - Optional {@link Validation.Classes.NumberValidatorConstructorParams | init params} for the
+            * new {@link Validation.Classes.NumberValidator | NumberValidator}.
+            */
+           constructor(params?: NumberValidatorConstructorParams<T, TC>);
+           /**
+            * Static method which validates that a supplied `unknown` value is a `number`.
+            * @param from - The `unknown` value to be tested.
+            * @returns Returns `true` if `from` is a `number`, or {@link Failure} with an error
+            * message if not.
+            */
+           static validateNumber<T extends number>(from: unknown): boolean | Failure<T>;
+       }
+
+       /**
+        * Parameters used to construct a {@link Validation.Classes.NumberValidator | NumberValidator}.
+        * @public
+        */
+       declare type NumberValidatorConstructorParams<T extends number = number, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
+
+       /**
+        * Helper function to create a {@link Converters.ObjectConverter | ObjectConverter<T>} which converts an object
+        * without changing shape, given a {@link Converters.FieldConverters | FieldConverters<T>} and an optional
+        * {@link Converters.ObjectConverterOptions | ObjectConverterOptions<T>} to further refine conversion beavior.
+        * @remarks
+        * By default, if all of the requested fields exist and can be converted, returns {@link Success}
+        * with a new object that contains the converted values under the original key names.  If any requried properties
+        * do not exist or cannot be converted, the entire conversion fails, returning {@link Failure} with additional
+        * error information.
+        *
+        * Fields that succeed but convert to undefined are omitted from the result object but do not
+        * fail the conversion.
+        * @param properties - An {@link Converters.FieldConverters | FieldConverters<T>} defining the shape of the
+        * source object and {@link Converter | converters} to be applied to each properties.
+        * @param options - An {@link Converters.ObjectConverterOptions | ObjectConverterOptions<T>} containing options
+        * for the object converter.
+        * @returns A new {@link Converters.ObjectConverter | ObjectConverter} which applies the specified conversions.
+        * {@label withOptions}
+        * @public
+        */
+       declare function object<T>(properties: FieldConverters<T>, options?: ObjectConverterOptions<T>): ObjectConverter<T>;
+
+       /**
+        * Helper function to create a {@link Converters.ObjectConverter | ObjectConverter<T>} which converts an object
+        * without changing shape, given a {@link Converters.FieldConverters | FieldConverters<T>} and a set of
+        * optional properties.
+        * @remarks
+        * By default, if all of the requested fields exist and can be converted, returns {@link Success}
+        * with a new object that contains the converted values under the original key names.  If any requried properties
+        * do not exist or cannot be converted, the entire conversion fails, returning {@link Failure} with additional
+        * error information.
+        *
+        * Fields that succeed but convert to undefined are omitted from the result object but do not
+        * fail the conversion.
+        * @param properties - An {@link Converters.FieldConverters | FieldConverters<T>} defining the shape of the
+        * source object and {@link Converter | converters} to be applied to each properties.
+        * @param optional - An array of `(keyof T)` listing the keys to be considered optional.
+        * {@label withKeys}
+        * @returns A new {@link Converters.ObjectConverter | ObjectConverter} which applies the specified conversions.
+        * @public
+        * @deprecated Use {@link Converters.(object:withOptions) | Converters.object(fields, options)} instead.
+        */
+       declare function object<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;
+
+       /**
+        * Helper function to create a {@link Validation.Classes.ObjectValidator | ObjectValidator} which validates
+        * an object in place.
+        * @param fields - A {@link Validation.Classes.FieldValidators | field validator definition}
+        * describing the validations to be applied.
+        * @param params - Optional {@link Validation.Classes.ObjectValidatorConstructorParams | parameters}
+        * to refine the behavior of the resulting {@link Validation.Validator | validator}.
+        * @returns A new {@link Validation.Validator | Validator} which validates the desired
+        * object in place.
+        * @public
+        */
+       declare function object_2<T, TC>(fields: FieldValidators<T, TC>, params?: Omit<ObjectValidatorConstructorParams<T, TC>, 'fields'>): ObjectValidator<T, TC>;
+
+       /**
+        * A {@link Converter} which converts an object of type `<T>` without changing shape, given
+        * a {@link Converters.FieldConverters | FieldConverters<T>} for the fields in the object.
+        * @remarks
+        * By default, if all of the required fields exist and can be converted, returns a new object with
+        * the converted values under the original key names.  If any required fields do not exist or cannot
+        * be converted, the entire conversion fails. See {@link Converters.ObjectConverterOptions | ObjectConverterOptions}
+        * for other conversion options.
+        * @public
+        */
+       declare class ObjectConverter<T, TC = unknown> extends BaseConverter<T, TC> {
+           /**
+            * Fields converted by this {@link Converters.ObjectConverter | ObjectConverter}.
+            */
+           readonly fields: FieldConverters<T>;
+           /**
+            * Options used to initialize this {@link Converters.ObjectConverter | ObjectConverter}.
+            */
+           readonly options: ObjectConverterOptions<T>;
+           /**
+            * Constructs a new {@link Converters.ObjectConverter | ObjectConverter<T>} using options
+            * supplied in a {@link Converters.ObjectConverterOptions | ObjectConverterOptions<T>}.
+            * @param fields - A {@link Converters.FieldConverters | FieldConverters<T>} containing
+            * a {@link Converter} for each field
+            * @param options - An optional @see ObjectConverterOptions to configure the conversion
+            * {@label withOptions}
+            */
+           constructor(fields: FieldConverters<T, TC>, options?: ObjectConverterOptions<T>);
+           /**
+            * Constructs a new {@link Converters.ObjectConverter | ObjectConverter<T>} with optional
+            * properties specified as an array of `keyof T`.
+            * @param fields - A {@link Converters.FieldConverters | FieldConverters<T>} containing
+            * a {@link Converter} for each field.
+            * @param optional - An array of `keyof T` listing fields that are not required.
+            * {@label withKeys}
+            */
+           constructor(fields: FieldConverters<T, TC>, optional?: (keyof T)[]);
+           /**
+            * Creates a new {@link Converters.ObjectConverter | ObjectConverter} derived from this one but with
+            * new optional properties as specified by a supplied {@link Converters.ObjectConverterOptions | ObjectConverterOptions<T>}.
+            * @param options - The {@link Converters.ObjectConverterOptions | options} to be applied to the new
+            * converter.
+            * @returns A new {@link Converters.ObjectConverter | ObjectConverter} with the additional optional source properties.
+            * {@label withOptions}
+            */
+           partial(options: ObjectConverterOptions<T>): ObjectConverter<Partial<T>, TC>;
+           /**
+            * Creates a new {@link Converters.ObjectConverter | ObjectConverter} derived from this one but with
+            * new optional properties as specified by a supplied array of `keyof T`.
+            * @param optional - The keys of the source object properties to be made optional.
+            * @returns A new {@link Converters.ObjectConverter | ObjectConverter} with the additional optional source
+            * properties.
+            * {@label withKeys}
+            */
+           partial(optional?: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
+           /**
+            * Creates a new {@link Converters.ObjectConverter | ObjectConverter} derived from this one but with
+            * new optional properties as specified by a supplied array of `keyof T`.
+            * @param addOptionalProperties - The keys to be made optional.
+            * @returns A new {@link Converters.ObjectConverter | ObjectConverter} with the additional optional source
+            * properties.
+            */
+           addPartial(addOptionalProperties: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
+       }
+
+       /**
+        * Options for an {@link Converters.ObjectConverter | ObjectConverter}.
+        * @public
+        */
+       declare interface ObjectConverterOptions<T> {
+           /**
+            * If present, lists optional fields. Missing non-optional fields cause an error.
+            */
+           optionalFields?: (keyof T)[];
+           /**
+            * If true, unrecognized fields yield an error.  If false or undefined (default),
+            * unrecognized fields are ignored.
+            */
+           strict?: boolean;
+       }
+
+       /**
+        * In-place {@link Validation.Validator | Validator} for an object of type `<T>`.
+        * @remarks
+        * By default, succeeds if all of the required fields exist and are validate, and fails if
+        * any required fields do not exist or are invalid.  See {@link Validation.Classes.ObjectValidatorOptions}
+        * for other validation options.
+        * @public
+        */
+       declare class ObjectValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
+           /**
+            * A {@link Validation.Classes.FieldValidators | FieldValidators} object specifying a
+            * {@link Validation.Validator | Validator} for each of the expected properties
+            */
+           readonly fields: FieldValidators<T>;
+           /**
+            * {@link Validation.Classes.ObjectValidatorOptions | Options} which apply to this
+            * validator.
+            */
+           readonly options: ObjectValidatorOptions<T, TC>;
+           /**
+            * @internal
+            */
+           protected readonly _innerValidators: FieldValidators<T>;
+           /**
+            * @internal
+            */
+           protected readonly _allowedFields?: Set<keyof T>;
+           /**
+            * Constructs a new {@link Validation.Classes.ObjectValidator | ObjectValidator<T>}.
+            * @param fields - A {@link Validation.Classes.FieldValidators | FieldValidators<T>} containing
+            * a {@link Validation.Validator | Validator} for each field.
+            * @param options - An optional {@link Validation.Classes.ObjectValidatorOptions} to configure
+            * validation.
+            */
+           constructor(params: ObjectValidatorConstructorParams<T, TC>);
+           /**
+            * Creates the actual {@link Validation.Classes.FieldValidators | FieldValidators<T>} to be
+            * used by this converter by applying any options or traits defined in the options
+            * to the field converters passed to the constructor.
+            * @param fields - The base {@link Validation.Classes.FieldValidators | FieldValidators<T>} passed
+            * in to the constructor.
+            * @param options - The {@link Validation.Classes.ObjectValidatorOptions | object validator options}
+            * passed in to the constructor.
+            * @returns A new {@link Validation.Classes.FieldValidators | FieldValidators} with the fully-configured
+            * individual {@link Validation.Validator | field validators} to be applied.
+            * @internal
+            */
+           protected static _resolveValidators<T, TC>(fields: FieldValidators<T, TC>, options?: ObjectValidatorOptions<T, TC>): FieldValidators<T, TC>;
+           /**
+            * Creates a new {@link Validation.Classes.ObjectValidator | ObjectValidator} derived from this one but with
+            * new optional properties as specified by a supplied
+            * {@link Validation.Classes.ObjectValidatorOptions | ObjectValidatorOptions<T>}.
+            * @param options - The {@link Validation.Classes.ObjectValidatorOptions | options} to be applied to the new
+            * {@link Validation.Classes.ObjectValidator | validator}.
+            * @returns A new {@link Validation.Classes.ObjectValidator | ObjectValidator} with the additional optional
+            * source properties.
+            */
+           partial(options?: ObjectValidatorOptions<T, TC>): ObjectValidator<Partial<T>, TC>;
+           /**
+            * Creates a new {@link Validation.Classes.ObjectValidator | ObjectValidator} derived from this one but with
+            * new optional properties as specified by a supplied array of `keyof T`.
+            * @param addOptionalProperties - The keys to be made optional.
+            * @returns A new {@link Validation.Classes.ObjectValidator | ObjectValidator} with the additional optional
+            * source properties.
+            */
+           addPartial(addOptionalFields: (keyof T)[]): ObjectValidator<Partial<T>, TC>;
+           /**
+            * {@inheritdoc Validation.ValidatorBase._validate}
+            * @internal
+            */
+           protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
+       }
+
+       /**
+        * Options for the {@link Validation.Classes.ObjectValidator | ObjectValidator} constructor.
+        * @public
+        */
+       declare interface ObjectValidatorConstructorParams<T, TC> extends ValidatorBaseConstructorParams<T, TC> {
+           /**
+            * A {@link Validation.Classes.FieldValidators | FieldValidators} object specifying a
+            * {@link Validation.Validator | Validator} for each of the expected properties
+            * of a result object.
+            */
+           fields: FieldValidators<T>;
+           /**
+            * Optional additional {@link Validation.Classes.ObjectValidatorOptions | ValidatorOptions} to
+            * configure validation.
+            */
+           options?: ObjectValidatorOptions<T, TC>;
+       }
+
+       /**
+        * Options for an {@link Validation.Classes.ObjectValidator | ObjectValidator}.
+        * @public
+        */
+       declare interface ObjectValidatorOptions<T, TC> extends ValidatorOptions<TC> {
+           /**
+            * If present, lists optional fields. Missing non-optional fields cause an error.
+            */
+           optionalFields?: (keyof T)[];
+           /**
+            * If true, unrecognized fields yield an error.  If false or undefined (default),
+            * unrecognized fields are ignored.
+            */
+           strict?: boolean;
+       }
+
+       /**
+        * A helper function to create a {@link Converter} for polymorphic values.  Returns a
+        * converter which Invokes the wrapped converters in sequence, returning the first successful
+        * result.  Returns an error if none of the supplied converters can convert the value.
+        * @remarks
+        * If `onError` is `ignoreErrors` (default), then errors from any of the
+        * converters are ignored provided that some converter succeeds.  If
+        * onError is `failOnError`, then an error from any converter fails the entire
+        * conversion.
+        *
+        * @param converters - An ordered list of {@link Converter | converters} to be considered.
+        * @param onError - Specifies treatment of unconvertable elements.
+        * @returns A new {@link Converter} which yields a value from the union of the types returned
+        * by the wrapped converters.
+        * @public
+        */
+       declare function oneOf<T, TC = unknown>(converters: Array<Converter<T, TC>>, onError?: OnError_2): Converter<T, TC>;
+
+       declare type OnError = 'failOnError' | 'ignoreErrors';
+
+       declare type OnError_2 = 'failOnError' | 'ignoreErrors';
+
+       /**
+        * A {@link Converter} to convert an optional `boolean` value.
+        * @remarks
+        * Values of type `boolean` or strings that match (case-insensitive) `'true'`
+        * or `'false'` are converted and returned.  Anything else returns {@link Success}
+        * with value `undefined`.
+        * @public
+        */
+       declare const optionalBoolean: Converter<boolean | undefined, undefined>;
+
+       /**
+        * A helper function to create a {@link Converter} which extracts and converts an optional element from an array.
+        * @remarks
+        * The resulting {@link Converter} returns {@link Success} with the converted value if the element exsist
+        * in the supplied array and can be converted. Returns {@link Success} with value `undefined` if the parameter
+        * is an array but the index is out of range. Returns {@link Failure} with a message if the supplied parameter
+        * is not an array, if the requested index is negative, or if the element cannot be converted.
+        * @param index - The index of the element to be extracted.
+        * @param converter - A {@link Converter} used to convert the extracted element.
+        * @returns A {@link Converter | Converter<T>} which extracts the specified element from an array.
+        * @public
+        */
+       declare function optionalElement<T, TC = undefined>(index: number, converter: Converter<T, TC>): Converter<T | undefined, TC>;
+
+       /**
+        * A helper function to create a {@link Converter} which extracts and convert a property specified
+        * by name from an object.
+        * @remarks
+        * The resulting {@link Converter} returns {@link Success} with the converted value of the correpsonding
+        * object property if the field exists and can be converted. Returns {@link Success} with value `undefined`
+        * if the supplied parametr is an object but the named field is not present.  Returns {@link Failure} with
+        * an error message otherwise.
+        * @param name - The name of the field to be extracted.
+        * @param converter - {@link Converter} used to convert the extracted field.
+        * @public
+        */
+       declare function optionalField<T, TC = undefined>(name: string, converter: Converter<T, TC>): Converter<T | undefined, TC>;
+
+       /**
+        * Applies a factory method to convert an optional `Map<string, TS>` into a `Record<string, TD>`
+        * @param src - The `Map` object to be converted, or `undefined`.
+        * @param factory - The factory method used to convert elements.
+        * @returns {@link Success} with the resulting record (empty if `src` is `undefined`) if conversion succeeds.
+            * Returns {@link Failure} with a message if an error occurs.
+            * @public
+            */
+        export declare function optionalMapToPossiblyEmptyRecord<TS, TD, TK extends string = string>(src: Map<TK, TS> | undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
+
+        /**
+         * Applies a factory method to convert an optional `Map<string, TS>` into a `Record<string, TD>` or `undefined`.
+         * @param src - The `Map` object to be converted, or `undefined`.
+         * @param factory - The factory method used to convert elements.
+         * @returns {@link Success} with the resulting record if conversion succeeds, or {@link Success} with `undefined` if
+             * `src` is `undefined`. Returns {@link Failure} with a message if an error occurs.
+             * @public
+             */
+         export declare function optionalMapToRecord<TS, TD, TK extends string = string>(src: Map<TK, TS> | undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD> | undefined>;
+
+         /**
+          * A {@link Converter} which converts an optional `number` value.
+          * @remarks
+          * Values of type `number` or numeric strings are converted and returned.
+          * Anything else returns {@link Success} with value `undefined`.
+          * @public
+          */
+         declare const optionalNumber: Converter<number | undefined, undefined>;
+
+         /**
+          * Applies a factory method to convert an optional `Record<TK, TS>` into a `Map<TK, TD>`, or `undefined`.
+          * @param src - The `Record` to be converted, or undefined.
+          * @param factory - The factory method used to convert elements.
+          * @returns {@link Success} with the resulting map if conversion succeeds, or {@link Success} with `undefined`
+              * if `src` is `undefined`. Returns {@link Failure} with a message if an error occurs.
+              * @public
+              */
+          export declare function optionalRecordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS> | undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD> | undefined>;
+
+          /**
+           * Applies a factory method to convert an optional `Record<TK, TS>` into a `Map<TK, TD>`
+           * @param src - The `Record` to be converted, or `undefined`.
+           * @param factory - The factory method used to convert elements.
+           * @returns {@link Success} with the resulting map (empty if `src` is `undefined`) if conversion succeeds.
+               * Returns {@link Failure} with a message if an error occurs.
+               * @public
+               */
+           export declare function optionalRecordToPossiblyEmptyMap<TS, TD, TK extends string = string>(src: Record<TK, TS> | undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>>;
+
+           /**
+            * A {@link Converter} which converts an optional `string` value. Values of type
+            * `string` are returned.  Anything else returns {@link Success} with value `undefined`.
+            * @public
+            */
+           declare const optionalString: Converter<string | undefined, unknown>;
+
+           /**
+            * Populates an an object based on a prototype full of field initializers that return {@link Result | Result<T[key]>}.
+            * Returns {@link Success} with the populated object if all initializers succeed, or {@link Failure} with a
+            * concatenated list of all error messages.
+            * @param initializers - An object with the shape of the target but with initializer functions for
+            * each property.
+            * @public
+            */
+           export declare function populateObject<T>(initializers: FieldInitializers<T>, order?: (keyof T)[]): Result<T>;
+
+           /**
+            * Propagates a {@link Success} or {@link Failure} {@link Result}, adding supplied
+            * event details as appropriate.
+            * @param result - The {@link Result} to be propagated.
+            * @param detail - The event detail (type `<TD>`) to be added to the {@link Result | result}.
+            * @param successDetail - An optional distinct event detail to be added to {@link Success} results.  If `successDetail`
+            * is omitted or `undefined`, then `detail` will be applied to {@link Success} results.
+            * @returns A new {@link DetailedResult | DetailedResult<T, TD>} with the success value or error
+            * message from the original `result` but with the specified detail added.
+            * @public
+            */
+           export declare function propagateWithDetail<T, TD>(result: Result<T>, detail: TD, successDetail?: TD): DetailedResult<T, TD>;
+
+           /**
+            * Simple implementation of a possibly open-ended range of some comparable
+            * type `<T>` with test and formatting.
+            * @public
+            */
+           export declare class RangeOf<T> implements RangeOfProperties<T> {
+               /**
+                * Minimum extent of the range.
+                */
+               readonly min?: T;
+               /**
+                * Maximum extent of the range.
+                */
+               readonly max?: T;
+               /**
+                * Creates a new {@link RangeOf | RangeOf<T>}.
+                * @param min - Optional mininum extent of the range.
+                * @param max - Optional maximum extent of the range.
+                */
+               constructor(min?: T, max?: T);
+               /**
+                * Static constructor for a {@link RangeOf | RangeOf<T>}.
+                * @param init - {@link RangeOfProperties | Range initializer}.
+                * @returns A new {@link RangeOf | RangeOf<T>}.
+                */
+               static createRange<T>(init?: RangeOfProperties<T>): Result<RangeOf<T>>;
+               /**
+                * Gets a formatted description of a {@link RangeOfProperties | RangeOfProperties<T>} given an
+                * optional set of formats and 'empty' value to use.
+                * @param range - The {@link RangeOfProperties | RangeOfProperties<T>} to be formatted.
+                * @param formats - Optionas {@link RangeOfFormats | formats} to use. Default is
+                * {@link DEFAULT_RANGEOF_FORMATS | DEFAULT_RANGEOF_FORMATS}.
+                * @param emptyValue - Value which represents unbounded minimum or maximum for this range. Default is `undefined`.
+                * @returns A string representation of the range.
+                */
+               static propertiesToString<T>(range: RangeOfProperties<T>, formats?: RangeOfFormats, emptyValue?: T): string | undefined;
+               /**
+                * Default comparison uses javascript built-in comparison.
+                * @param t1 - First value to be compared.
+                * @param t2 - Second value to be compared.
+                * @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
+                * and `'equal'` if `t1` and `t2` are equal.
+                * @internal
+                */
+               protected static _defaultCompare<T>(t1: T, t2: T): 'less' | 'equal' | 'greater';
+               /**
+                * Checks if a supplied value is within this range.
+                * @param t - The value to be tested.
+                * @returns `'included'` if `t` falls within the range, `'less'` if `t` falls
+                * below the minimum extent of the range and `'greater'` if `t` is above the
+                * maximum extent.
+                */
+               check(t: T): 'less' | 'included' | 'greater';
+               /**
+                * Determines if a supplied value is within this range.
+                * @param t - The value to be tested.
+                * @returns Returns `true` if `t` falls within the range, `false` otherwise.
+                */
+               includes(t: T): boolean;
+               /**
+                * Finds the transition value that would bring a supplied value `t` into
+                * range.
+                * @param t - The value to be tested.
+                * @returns The minimum extent of the range if `t` is below the range or
+                * the maximum extent of the range if `t` is above the range.  Returns
+                * `undefined` if `t` already falls within the range.
+                */
+               findTransition(t: T): T | undefined;
+               /**
+                * Formats the minimum and maximum values of this range.
+                * @param format - A format function used to format the values.
+                * @returns A {@link RangeOfProperties | RangeOfProperties<string>} contaning the
+                * formatted representation of the {@link RangeOf.min | minimum} and {@link RangeOf.max | maximum}
+                * extent of the range, or `undefined` for an extent that is not present.
+                */
+               toFormattedProperties(format: (value: T) => string | undefined): RangeOfProperties<string>;
+               /**
+                * Formats this range using the supplied format function.
+                * @param format - Format function used to format minimum and maxiumum extent values.
+                * @param formats - The {@link RangeOfFormats | format strings} used to format the range
+                * (default {@link DEFAULT_RANGEOF_FORMATS}).
+                * @returns Returns a formatted representation of this range.
+                */
+               format(format: (value: T) => string | undefined, formats?: RangeOfFormats): string | undefined;
+               /**
+                * Inner compare method can be overriden by a derived class.
+                * @param t1 - First value to compare.
+                * @param t2 - Second value to compare.
+                * @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
+                * and `'equal'` if `t1` and `t2` are equal.
+                * @internal
+                */
+               protected _compare(t1: T, t2: T): 'less' | 'equal' | 'greater';
+           }
+
+           /**
+            * A helper wrapper to construct a {@link Converter} which converts to {@link RangeOf | RangeOf<T>}
+            * where `<T>` is some comparable type.
+            * @param converter - {@link Converter} used to convert `min` and `max` extent of the range.
+            * @public
+            */
+           declare function rangeOf<T, TC = unknown>(converter: Converter<T, TC>): Converter<RangeOf<T>, TC>;
+
+           /**
+            * Format strings (in mustache format) to
+            * use for both open-ended and complete
+            * {@link RangeOf | RangeOf<T>}.
+            * @public
+            */
+           export declare interface RangeOfFormats {
+               minOnly: string;
+               maxOnly: string;
+               minMax: string;
+           }
+
+           /**
+            * Represents a generic range of some comparable type `<T>`.
+            * @public
+            */
+           export declare interface RangeOfProperties<T> {
+               readonly min?: T;
+               readonly max?: T;
+           }
+
+           /**
+            * A helper wrapper to construct a {@link Converter} which converts to an arbitrary strongly-typed
+            * range of some comparable type.
+            * @param converter - {@link Converter} used to convert `min` and `max` extent of the range.
+            * @param constructor - Static constructor to instantiate the object.
+            * @public
+            */
+           declare function rangeTypeOf<T, RT extends RangeOf<T>, TC = unknown>(converter: Converter<T, TC>, constructor: (init: RangeOfProperties<T>) => Result<RT>): Converter<RT, TC>;
+
+           /**
+            * Reads a CSV file from a supplied path.
+            * @param srcPath - Source path from which the file is read.
+            * @returns The contents of the file.
+            * @beta
+            */
+           declare function readCsvFileSync(srcPath: string): Result<unknown>;
+
+           /**
+            * A helper function to create a {@link Converter} which converts the `string`-keyed properties
+            * using a supplied {@link Converter | Converter<T>} to produce a `Record<string, T>`.
+            * @remarks
+            * The resulting converter fails conversion if any element cannot be converted.
+            * @param converter - {@link Converter} used to convert each item in the source object.
+            * @returns A {@link Converter} which returns `Record<string, T>`.
+            * {@label default}
+            * @public
+            */
+           declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>): Converter<Record<TK, T>, TC>;
+
+           /**
+            * A helper function to create a {@link Converter} which converts the `string`-keyed properties
+            * using a supplied {@link Converter | Converter<T>} to produce a `Record<string, T>` and optionally
+            * specified handling of elements that cannot be converted.
+            * @remarks
+            * if `onError` is `'fail'` (default), then the entire conversion fails if any key or element
+            * cannot be converted.  If `onError` is `'ignore'`, failing elements are silently ignored.
+            * @param converter - {@link Converter} used to convert each item in the source object.
+            * @returns A {@link Converter} which returns `Record<string, T>`.
+            * {@label withOnError}
+            * @public
+            */
+           declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, onError: 'fail' | 'ignore'): Converter<Record<TK, T>, TC>;
+
+           /**
+            * A helper function to create a {@link Converter} which converts the `string`-keyed properties
+            * using a supplied {@link Converter | Converter<T>} to produce a `Record<TK, T>`.
+            * @remarks
+            * If present, the supplied {@link Converters.KeyedConverterOptions | options} can provide a strongly-typed
+            * converter for keys and/or control the handling of elements that fail conversion.
+            * @param converter - {@link Converter} used to convert each item in the source object.
+            * @param options - Optional {@link Converters.KeyedConverterOptions | KeyedConverterOptions<TK, TC>} which
+            * supplies a key converter and/or error-handling options.
+            * @returns A {@link Converter} which returns `Record<TK, T>`.
+            * {@label withOptions}
+            * @public
+            */
+           declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, options: KeyedConverterOptions<TK, TC>): Converter<Record<TK, T>, TC>;
+
+           /**
+            * Applies a factory method to convert a `Record<TK, TS>` into a `Map<TK, TD>`.
+            * @param src - The `Record` to be converted.
+            * @param factory - The factory method used to convert elements.
+            * @returns {@link Success} with the resulting map on success, or {@link Failure} with a
+                * message if an error occurs.
+                * @public
+                */
+            export declare function recordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>>;
+
+            /**
+             * Represents the {@link IResult | result} of some operation or sequence of operations.
+             * @remarks
+             * {@link Success | Success<T>} and {@link Failure | Failure<T>} share the common
+             * contract {@link IResult}, enabling comingled discriminated usage.
+             * @public
+             */
+            export declare type Result<T> = Success<T> | Failure<T>;
+
+            /**
+             * Type inference to determine the detail type `TD` of a {@link DetailedResult | DetailedResult<T, TD>}.
+             * @beta
+             */
+            export declare type ResultDetailType<T> = T extends DetailedResult<unknown, infer TD> ? TD : never;
+
+            /**
+             * Type inference to determine the result type of an {@link Result}.
+             * @beta
+             */
+            export declare type ResultValueType<T> = T extends Result<infer TV> ? TV : never;
+
+            /**
+             * Helper function to create a {@link Converters.ObjectConverter | ObjectConverter} which converts an object
+             * without changing shape, a {@link Converters.FieldConverters | FieldConverters<T>} and an optional
+             * {@link Converters.StrictObjectConverterOptions | StrictObjectConverterOptions<T>} to further refine
+             * conversion behavior.
+             *
+             * @remarks
+             * Fields that succeed but convert to undefined are omitted from the result object but do not
+             * fail the conversion.
+             *
+             * The conversion fails if any unexpected fields are encountered.
+             *
+             * @param properties - An object containing defining the shape and converters to be applied.
+             * @param options - An optional @see StrictObjectConverterOptions<T> containing options for the object converter.
+             * @returns A new {@link Converters.ObjectConverter | ObjectConverter} which applies the specified conversions.
+             * {@label withOptions}
+             * @public
+             */
+            declare function strictObject<T>(properties: FieldConverters<T>, options?: StrictObjectConverterOptions<T>): ObjectConverter<T>;
+
+            /**
+             * Helper function to create a {@link Converters.ObjectConverter | ObjectConverter} which converts an object
+             * without changing shape, a {@link Converters.FieldConverters | FieldConverters<T>} and an optional
+             * {@link Converters.StrictObjectConverterOptions | StrictObjectConverterOptions<T>} to further refine
+             * conversion behavior.
+             *
+             * @remarks
+             * Fields that succeed but convert to undefined are omitted from the result object but do not
+             * fail the conversion.
+             *
+             * The conversion fails if any unexpected fields are encountered.
+             *
+             * @param properties - An object containing defining the shape and converters to be applied.
+             * @param optional - An array of `keyof T` containing keys to be considered optional.
+             * @returns A new {@link Converters.ObjectConverter | ObjectConverter} which applies the specified conversions.
+             * {@label withKeys}
+             * @deprecated Use {@link Converters.(strictObject:withOptions) | Converters.strictObject(options)} instead.
+             * @public
+             */
+            declare function strictObject<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;
+
+            /**
+             * Options for the {@link Converters.(strictObject:withOptions)} helper function.
+             * @public
+             */
+            declare type StrictObjectConverterOptions<T> = Omit<ObjectConverterOptions<T>, 'strict'>;
+
+            /**
+             * A converter to convert unknown to string. Values of type
+             * string succeed.  Anything else fails.
+             * @public
+             */
+            declare const string: StringConverter<string, unknown>;
+
+            /**
+             * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
+             * @public
+             */
+            declare const string_2: StringValidator<string, unknown>;
+
+            /**
+             * {@link Converter} to convert an `unknown` to an array of `string`.
+             * @remarks
+             * Returns {@link Success} with the the supplied value if it as an array
+             * of strings, returns {@link Failure} with an error message otherwise.
+             * @public
+             */
+            declare const stringArray: Converter<string[], unknown>;
+
+            /**
+             * The {@link Converters.StringConverter | StringConverter} class extends {@link BaseConverter}
+             * to provide string-specific helper methods.
+             * @public
+             */
+            declare class StringConverter<T extends string = string, TC = unknown> extends BaseConverter<T, TC> {
+                /**
+                 * Construct a new {@link Converters.StringConverter | StringConverter}.
+                 * @param defaultContext - Optional context used by the conversion.
+                 * @param traits - Optional traits to be applied to the conversion.
+                 * @param converter - Optional conversion function to be used for the conversion.
+                 */
+                constructor(defaultContext?: TC, traits?: ConverterTraits, converter?: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>);
+                /**
+                 * @internal
+                 */
+                protected static _convert<T extends string>(from: unknown): Result<T>;
+                /**
+                 * @internal
+                 */
+                protected static _wrap<T extends string, TC>(wrapped: StringConverter<T, TC>, converter: (from: T) => Result<T>, traits?: ConverterTraits): StringConverter<T, TC>;
+                /**
+                 * Returns a {@link Converters.StringConverter | StringConverter} which constrains the result to match
+                 * a supplied string.
+                 * @param match - The string to be matched
+                 * @param options - Optional {@link Converters.StringMatchOptions} for this conversion.
+                 * @returns {@link Success} with a matching string or {@link Failure} with an informative
+                     * error if the string does not match.
+                     * {@label string}
+                     */
+                 matching(match: string, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+                 /**
+                  * Returns a {@link Converters.StringConverter | StringConverter} which constrains the result to match
+                  * one of a supplied array of strings.
+                  * @param match - The array of allowed strings.
+                  * @param options - Optional {@link Converters.StringMatchOptions} for this conversion.
+                  * @returns {@link Success} with a matching string or {@link Failure} with an informative
+                      * error if the string does not match.
+                      * {@label array}
+                      */
+                  matching(match: string[], options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+                  /**
+                   * Returns a {@link Converters.StringConverter | StringConverter} which constrains the result to match
+                   * one of a supplied `Set` of strings.
+                   * @param match - The `Set` of allowed strings.
+                   * @param options - Optional {@link Converters.StringMatchOptions} for this conversion.
+                   * @returns {@link Success} with a matching string or {@link Failure} with an informative
+                       * error if the string does not match.
+                       * {@label set}
+                       */
+                   matching(match: Set<T>, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+                   /**
+                    * Returns a {@link Converters.StringConverter | StringConverter} which constrains the result to match
+                    * a supplied regular expression.
+                    * @param match - The regular expression to be used as a constraint.
+                    * @param options - Optional {@link Converters.StringMatchOptions} for this conversion
+                    * @returns {@link Success} with a matching string or {@link Failure} with an informative
+                        * error if the string does not match.
+                        * {@label regexp}
+                        */
+                    matching(match: RegExp, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+                   }
+
+                   /**
+                    * Options for {@link Converters.StringConverter | StringConverter}
+                    * matching method
+                    * @public
+                    */
+                   declare interface StringMatchOptions {
+                       /**
+                        * An optional message to be displayed if a non-matching string
+                        * is encountered.
+                        */
+                       message?: string;
+                   }
+
+                   /**
+                    * An in-place {@link Validation.Validator | Validator} for `string` values.
+                    * @public
+                    */
+                   declare class StringValidator<T extends string = string, TC = unknown> extends GenericValidator<T, TC> {
+                       /**
+                        * Constructs a new {@link Validation.Classes.StringValidator | StringValidator}.
+                        * @param params - Optional {@link Validation.Classes.StringValidatorConstructorParams | init params}
+                        * for the new {@link Validation.Classes.StringValidator | StringValidator}.
+                        */
+                       constructor(params?: StringValidatorConstructorParams<T, TC>);
+                       /**
+                        * Static method which validates that a supplied `unknown` value is a `string`.
+                        * @param from - The `unknown` value to be tested.
+                        * @returns Returns `true` if `from` is a `string`, or {@link Failure} with an error
+                        * message if not.
+                        */
+                       static validateString<T extends string>(from: unknown): boolean | Failure<T>;
+                   }
+
+                   /**
+                    * Parameters used to construct a {@link Validation.Classes.StringValidator | StringValidator}.
+                    * @public
+                    */
+                   declare type StringValidatorConstructorParams<T extends string = string, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
+
+                   /**
+                    * Returns {@link Success | Success<T>} with the supplied result value.
+                    * @param value - The successful result value to be returned
+                    * @public
+                    */
+                   export declare function succeed<T>(value: T): Success<T>;
+
+                   /**
+                    * Returns {@link DetailedSuccess | DetailedSuccess<T, TD>} with a supplied value and optional
+                    * detail.
+                    * @param value - The value of type `<T>` to be returned.
+                    * @param detail - An optional detail of type `<TD>` to be returned.
+                    * @returns A {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied value
+                    * and detail, if supplied.
+                    * @public
+                    */
+                   export declare function succeedWithDetail<T, TD>(value: T, detail?: TD): DetailedSuccess<T, TD>;
+
+                   /**
+                    * Reports a successful {@link IResult | result} from some operation and the
+                    * corresponding value.
+                    * @public
+                    */
+                   export declare class Success<T> implements IResult<T> {
+                       /**
+                        * {@inheritdoc IResult.success}
+                        */
+                       readonly success = true;
+                       /**
+                        * @internal
+                        */
+                       private readonly _value;
+                       /**
+                        * Constructs a {@link Success} with the supplied value.
+                        * @param value - The value to be returned.
+                        */
+                       constructor(value: T);
+                       /**
+                        * The result value returned by the successful operation.
+                        */
+                       get value(): T;
+                       /**
+                        * {@inheritdoc IResult.isSuccess}
+                        */
+                       isSuccess(): this is Success<T>;
+                       /**
+                        * {@inheritdoc IResult.isFailure}
+                        */
+                       isFailure(): this is Failure<T>;
+                       /**
+                        * {@inheritdoc IResult.getValueOrThrow}
+                        */
+                       getValueOrThrow(_logger?: IResultLogger): T;
+                       /**
+                        * {@inheritdoc IResult.getValueOrDefault}
+                        */
+                       getValueOrDefault(dflt?: T): T | undefined;
+                       /**
+                        * {@inheritdoc IResult.onSuccess}
+                        */
+                       onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN>;
+                       /**
+                        * {@inheritdoc IResult.onFailure}
+                        */
+                       onFailure(_: FailureContinuation<T>): Result<T>;
+                       /**
+                        * {@inheritdoc IResult.withFailureDetail}
+                        */
+                       withFailureDetail<TD>(_detail: TD): DetailedResult<T, TD>;
+                       /**
+                        * {@inheritdoc IResult.withDetail}
+                        */
+                       withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;
+                   }
+
+                   /**
+                    * Continuation callback to be called in the event that an
+                    * {@link Result} is successful.
+                    * @public
+                    */
+                   export declare type SuccessContinuation<T, TN> = (value: T) => Result<TN>;
+
+                   /**
+                    * Helper function to create a {@link Converters.StringConverter | StringConverter} which converts
+                    * `unknown` to `string`, applying template conversions supplied at construction time or at
+                    * runtime as context.
+                    * @remarks
+                    * Template conversions are applied using `mustache` syntax.
+                    * @param defaultContext - Optional default context to use for template values.
+                    * @returns A new {@link Converter} returning `string`.
+                    * @public
+                    */
+                   declare function templateString(defaultContext?: unknown): StringConverter<string, unknown>;
+
+                   /**
+                    * Helper to create a {@link Converter} which converts a source object to a new object with a
+                    * different shape.
+                    *
+                    * @remarks
+                    * On successful conversion, the resulting {@link Converter} returns {@link Success} with a new
+                    * object, which contains the converted values under the key names specified at initialization time.
+                    * It returns {@link Failure} with an error message if any fields to be extracted do not exist
+                    * or cannot be converted.
+                    *
+                    * Fields that succeed but convert to undefined are omitted from the result object but do not
+                    * fail the conversion.
+                    *
+                    * @param properties - An object with key names that correspond to the target object and an
+                    * appropriate {@link Converters.FieldConverters | FieldConverter} which extracts and converts
+                    * a single filed from the source object.
+                    * @returns A {@link Converter} with the specified conversion behavior.
+                    * @public
+                    */
+                   declare function transform<T, TC = unknown>(properties: FieldConverters<T, TC>): Converter<T, TC>;
+
+                   /**
+                    * Helper function to create  a {@link Converter} which validates that a supplied value is
+                    * of a type validated by a supplied validator function and returns it.
+                    * @remarks
+                    * If `validator` succeeds, this {@link Converter} returns {@link Success} with the supplied
+                    * value of `from` coerced to type `<T>`.  Returns a {@link Failure} with additional
+                    * information otherwise.
+                    * @param validator - A validator function to determine if the converted value is valid.
+                    * @param description - A description of the validated type for use in error messages.
+                    * @returns A new {@link Converter | Converter<T>} which applies the supplied validation.
+                    * @public
+                    */
+                   declare function validateWith<T, TC = undefined>(validator: (from: unknown) => from is T, description?: string): Converter<T, TC>;
+
+                   declare namespace Validation {
+                       export {
+                           Base,
+                           Classes,
+                           Validators,
+                           FunctionConstraintTrait,
+                           ConstraintTrait,
+                           ValidatorTraitValues,
+                           defaultValidatorTraits,
+                           ValidatorTraits,
+                           ValidatorOptions,
+                           Constraint,
+                           Validator
+                       }
+                   }
+                   export { Validation }
+
+                   /**
+                    * In-place validation that a supplied unknown matches some
+                    * required characteristics (type, values, etc).
+                    * @public
+                    */
+                   declare interface Validator<T, TC = undefined> {
+                       /**
+                        * {@link Validation.ValidatorTraits | Traits} describing this validation.
+                        */
+                       readonly traits: ValidatorTraits;
+                       /**
+                        * Indicates whether this element is explicitly optional.
+                        */
+                       readonly isOptional: boolean;
+                       /**
+                        * The brand for a branded type.
+                        */
+                       readonly brand: string | undefined;
+                       /**
+                        * Tests to see if a supplied `unknown` value matches this
+                        * validation.
+                        * @param from - The `unknown` value to be tested.
+                        * @param context - Optional validation context.
+                        * @returns {@link Success} with the typed, validated value,
+                            * or {@link Failure} with an error message if validation fails.
+                            */
+                        validate(from: unknown, context?: TC): Result<T>;
+                        /**
+                         * Tests to see if a supplied `unknown` value matches this
+                         * validation.  Accepts `undefined`.
+                         * @param from - The `unknown` value to be tested.
+                         * @param context - Optional validation context.
+                         * @returns {@link Success} with the typed, validated value,
+                             * or {@link Failure} with an error message if validation fails.
+                             */
+                         validateOptional(from: unknown, context?: TC): Result<T | undefined>;
+                         /**
+                          * Non-throwing type guard
+                          * @param from - The value to be tested.
+                          * @param context - Optional validation context.
+                          */
+                         guard(from: unknown, context?: TC): from is T;
+                         /**
+                          * Creates an {@link Validation.Validator | in-place validator}
+                          * which is derived from this one but which also matches `undefined`.
+                          */
+                         optional(): Validator<T | undefined, TC>;
+                         /**
+                          * Creates an {@link Validation.Validator | in-place validator}
+                          * which is derived from this one but which applies additional constraints.
+                          * @param constraint - the constraint to be applied
+                          * @param trait - As optional {@link Validation.ConstraintTrait | ConstraintTrait}
+                          * to be applied to the resulting {@link Validation.Validator | Validator}.
+                          * @returns A new {@link Validation.Validator | Validator}.
+                          */
+                         withConstraint(constraint: Constraint<T>, trait?: ConstraintTrait): Validator<T, TC>;
+                         /**
+                          * Creates a new {@link Validation.Validator | in-place validator} which
+                          * is derived from this one but which matches a branded result.
+                          * @param brand - The brand to be applied.
+                          */
+                         withBrand<B extends string>(brand: B): Validator<Brand<T, B>, TC>;
+                        }
+
+                        /**
+                         * Abstract base helper class for specific validator implementations
+                         * @internal
+                         */
+                        declare abstract class ValidatorBase<T, TC = undefined> extends GenericValidator<T, TC> {
+                            /**
+                             * Inner constructor
+                             * @param params - Initialization params.
+                             * @internal
+                             */
+                            protected constructor(params: Partial<ValidatorBaseConstructorParams<T, TC>>);
+                            /**
+                             * Abstract validation method to me implemented by derived classes.
+                             * @param from - Value to be converted.
+                             * @param context - Optional validation context.
+                             * @returns `true` if `from` is valid, {@link Failure | Failure<T>}
+                             * with an error message if `from` is invalid.
+                             * @internal
+                             */
+                            protected abstract _validate(from: unknown, context?: TC): boolean | Failure<T>;
+                        }
+
+                        declare type ValidatorBaseConstructorParams<T, TC> = Omit<GenericValidatorConstructorParams<T, TC>, 'validator'>;
+
+                        /**
+                         * Type for a validation function, which validates that a supplied `unknown`
+                         * value is a valid value of type `<T>`, possibly as influenced by
+                         * an optionally-supplied validation context of type `<TC>`.
+                         * @public
+                         */
+                        declare type ValidatorFunc<T, TC> = (from: unknown, context?: TC) => boolean | Failure<T>;
+
+                        /**
+                         * Options that apply to any {@link Validation.Validator | Validator}.
+                         * @public
+                         */
+                        declare interface ValidatorOptions<TC> {
+                            defaultContext?: TC;
+                        }
+
+                        declare namespace Validators {
+                            export {
+                                object_2 as object,
+                                string_2 as string,
+                                number_2 as number,
+                                boolean_2 as boolean
+                            }
+                        }
+
+                        /**
+                         * Generic implementation of {@link Validation.ValidatorTraitValues | ValidatorTraitValues}.
+                         * @public
+                         */
+                        declare class ValidatorTraits implements ValidatorTraitValues {
+                            /**
+                             * {@inheritdoc Validation.ValidatorTraitValues.isOptional}
+                             */
+                            readonly isOptional: boolean;
+                            /**
+                             * {@inheritdoc Validation.ValidatorTraitValues.brand}
+                             */
+                            readonly brand?: string;
+                            /**
+                             * {@inheritdoc Validation.ValidatorTraitValues.constraints}
+                             */
+                            readonly constraints: ConstraintTrait[];
+                            /**
+                             * Constructs a new {@link Validation.ValidatorTraits | ValidatorTraits} optionally
+                             * initialized with the supplied base and initial values.
+                             * @remarks
+                             * Initial values take priority over base values, which fall back to the global default values.
+                             * @param init - Partial initial values to be set in the resulting {@link Validation.Validator | Validator}.
+                             * @param base - Base values to be used when no initial values are present.
+                             */
+                            constructor(init?: Partial<ValidatorTraitValues>, base?: ValidatorTraitValues);
+                        }
+
+                        /**
+                         * Interface describing the supported validator traits.
+                         * @public
+                         */
+                        declare interface ValidatorTraitValues {
+                            /**
+                             * Indicates whether the validator accepts `undefined` as
+                             * a valid value.
+                             */
+                            readonly isOptional: boolean;
+                            /**
+                             * If present, indicates that the result will be branded
+                             * with the corresponding brand.
+                             */
+                            readonly brand?: string;
+                            /**
+                             * Zero or more additional {@link Validation.ConstraintTrait | ConstraintTrait}s
+                             * describing additional constraints applied by this {@link Validation.Validator | Validator}.
+                             */
+                            readonly constraints: ConstraintTrait[];
+                        }
+
+                        /**
+                         * Deprecated alias for @see literal
+                         * @param value - The value to be compared.
+                         * @deprecated Use {@link Converters.literal} instead.
+                         * @internal
+                         */
+                        declare const value: typeof literal;
+
+                        export { }