@fgv/ts-utils 2.1.0 → 2.1.1-alpha.0

package/dist/ts-utils.d.ts

@@ -247,14 +247,6 @@ declare namespace Classes {
     }
 }
 
-/**
- * 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
@@ -457,7 +449,6 @@ declare namespace Converters {
         isA,
         oneOf,
         arrayOf,
-        extendedArrayOf,
         recordOf,
         mapOf,
         validateWith,
@@ -470,8 +461,7 @@ declare namespace Converters {
         discriminatedObject,
         transform,
         transformObject,
-        rangeTypeOf,
-        rangeOf,
+        OnError_2 as OnError,
         string,
         value,
         number,
@@ -500,29 +490,6 @@ declare interface ConverterTraits {
     readonly brand?: string;
 }
 
-declare namespace Csv {
-    export {
-        readCsvFileSync,
-        CsvOptions
-    }
-}
-export { Csv }
-
-/**
- * Options for {@link Csv.readCsvFileSync}
- * @beta
- */
-declare interface CsvOptions {
-    delimiter?: string;
-}
-
-/**
- * Default {@link Experimental.RangeOfFormats | formats} to use for both
- * open-ended and complete {@link Experimental.RangeOf | RangeOf<T>}.
- * @public
- */
-declare const DEFAULT_RANGEOF_FORMATS: RangeOfFormats;
-
 /**
  * Default {@link Validation.ValidatorTraitValues | validation traits}.
  * @public
@@ -727,90 +694,6 @@ declare function enumeratedValue<T>(values: T[]): Converter<T, T[]>;
  */
 declare function enumeratedValue_2<T extends string>(values: T[]): Validator<T, T[]>;
 
-declare namespace Experimental {
-    export {
-        ExtendedArray,
-        formatList,
-        FormatTargets,
-        Formattable,
-        FormattableBase,
-        Formatter,
-        FormattersByExtendedTarget,
-        FormattersByTarget,
-        RangeOfProperties,
-        RangeOfFormats,
-        DEFAULT_RANGEOF_FORMATS,
-        RangeOf
-    }
-}
-export { Experimental }
-
-/**
- * An experimental array template which extend built-in `Array` to include a handful
- * of predicates which return {@link Result | Result<T>}.
- * @beta
- */
-declare class ExtendedArray<T> extends Array<T> {
-    readonly itemDescription: string;
-    /**
-     * Constructs an {@link Experimental.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 Experimental.ExtendedArray}
-     * @param a - The `Array` to be tested.
-     * @returns Returns `true` if `a` is an {@link Experimental.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 Experimental.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 Experimental.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 Experimental.ExtendedArray}.
-     * @returns A new (non-extended) `Array<T>`.
-     */
-    all(): T[];
-}
-
-/**
- * A helper function to create a {@link Converter} which converts `unknown` to {@link Experimental.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 unconvertible 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.
@@ -856,13 +739,16 @@ export declare class Failure<T> implements IResult<T> {
     /**
      * {@inheritdoc IResult.orDefault}
      */
-    orDefault(dflt?: T): T | undefined;
+    orDefault(dflt: T): T;
+    orDefault(): T | undefined;
     /**
      * {@inheritdoc IResult.getValueOrThrow}
+     * @deprecated Use {@link Failure.orThrow | orThrow} instead.
      */
     getValueOrThrow(logger?: IResultLogger): never;
     /**
      * {@inheritdoc IResult.getValueOrDefault}
+     * @deprecated Use {@link Failure.orDefault | orDefault} instead.
      */
     getValueOrDefault(dflt?: T): T | undefined;
     /**
@@ -971,2037 +857,1736 @@ declare type FieldValidators<T, TC = unknown> = {
 };
 
 /**
- * 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 Experimental.Formatter | Formatter<T>} used to format each item.
- * @returns The resulting string.
- * @beta
+ * A {@link Validation.ConstraintTrait | ConstraintTrait} indicating that
+ * a {@link Validation.Constraint | Constraint<T>} function provides an
+ * additional constraint implementation.
+ * @public
  */
-declare function formatList<T>(format: string, items: T[], itemFormatter: Formatter<T>): Result<string>;
+declare interface FunctionConstraintTrait {
+    type: 'function';
+}
 
 /**
- * Interface for an object that can be formatted.
- * @beta
+ * Generic base implementation for an in-place {@link Validation.Validator | Validator}.
+ * @public
  */
-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>;
-    }
-
+declare class GenericValidator<T, TC = undefined> implements Validator<T, TC> {
     /**
-     * Base class which adds common formatting.
-     * @beta
+     * {@inheritdoc Validation.Validator.traits}
      */
-    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 Experimental.Formattable.format}
-         */
-        format(template: string): Result<string>;
-    }
-
+    readonly traits: ValidatorTraits;
     /**
-     * Destination format for some formatted string.
-     * @beta
+     * @internal
      */
-    declare type FormatTargets = 'text' | 'markdown' | 'embed';
-
+    protected readonly _validator: ValidatorFunc<T, TC>;
     /**
-     * Type definition for a formatting function, which takes a `string` and an
-     * item and returns {@link Result | Result<string>}.
-     * @beta
+     * @internal
      */
-    declare type Formatter<T> = (format: string, item: T) => Result<string>;
-
+    protected readonly _options: ValidatorOptions<TC>;
     /**
-     * A collection of {@link Experimental.Formatter | formatters} indexed by target name, to enable
-     * different format methods per output target.
-     * @beta
+     * Constructs a new {@link Validation.Base.GenericValidator | GenericValidator<T>}.
+     * @param params - The {@link Validation.Base.GenericValidatorConstructorParams | constructor params}
+     * used to configure validation.
      */
-    declare type FormattersByExtendedTarget<TFT extends FormatTargets, T> = Record<TFT, Formatter<T>>;
-
+    constructor(params: Partial<GenericValidatorConstructorParams<T, TC>>);
     /**
-     * A collection of {@link Experimental.Formatter | formatters} indexed by the
-     * {@link Experimental.FormatTargets | default supported target formats}.
-     * @beta
+     * {@inheritdoc Validation.Validator.isOptional}
      */
-    declare type FormattersByTarget<T> = FormattersByExtendedTarget<FormatTargets, T>;
-
+    get isOptional(): boolean;
     /**
-     * A {@link Validation.ConstraintTrait | ConstraintTrait} indicating that
-     * a {@link Validation.Constraint | Constraint<T>} function provides an
-     * additional constraint implementation.
-     * @public
+     * {@inheritdoc Validation.Validator.brand}
      */
-    declare interface FunctionConstraintTrait {
-        type: 'function';
-    }
-
+    get brand(): string | undefined;
     /**
-     * Generic base implementation for an in-place {@link Validation.Validator | Validator}.
-     * @public
+     * {@inheritdoc Validation.Validator.validate}
      */
-    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;
-    }
-
+    validate(from: unknown, context?: TC): Result<T>;
     /**
-     * Options used to initialize a {@link Validation.Base.GenericValidator | GenericValidator}.
-     * @public
+     * {@inheritdoc Validation.Validator.validateOptional}
      */
-    declare interface GenericValidatorConstructorParams<T, TC> {
-        options?: ValidatorOptions<TC>;
-        traits?: Partial<ValidatorTraits>;
-        validator?: ValidatorFunc<T, TC>;
-    }
-
+    validateOptional(from: unknown, context?: TC): Result<T | undefined>;
     /**
-     * Gets the type of a property specified by key from an arbitrary object.
-     * @param key - The key specifying the property to be tested.
-     * @param item - The object from which the property is to be tested.
-     * @returns The type of the requested property, or `undefined` if the
-     * property does not exist.
-     * @example
-     * Returns `'undefined'` (a string) if the property exists but has the value
-     * undefined but `undefined` (the literal) if the property does not exist.
-     * @public
+     * {@inheritdoc Validation.Validator.guard}
      */
-    export declare function getTypeOfProperty<T extends object>(key: string | number | symbol, item: T): 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'undefined' | 'object' | 'function' | undefined;
-
+    guard(from: unknown, context?: TC): from is T;
     /**
-     * Gets the value of a property specified by key from an arbitrary object,
-     * or a default value if the property does not exist.
-     * @param key - The key specifying the property to be retrieved.
-     * @param item - The object from which the property is to be retrieved.
-     * @param defaultValue - An optional default value to be returned if the property
-     * is not present (default `undefined`).
-     * @returns The value of the requested property, or the default value if the
-     * requested property does not exist.
-     * @public
+     * {@inheritdoc Validation.Validator.optional}
      */
-    export declare function getValueOfPropertyOrDefault<T extends object>(key: string | number | symbol, item: T, defaultValue?: unknown): unknown | undefined;
-
-    declare namespace Hash {
-        export {
-            computeHash,
-            Normalizer_2 as Normalizer
-        }
-    }
-    export { Hash }
-
+    optional(): Validator<T | undefined, TC>;
     /**
-     * Infers the type that will be returned by an instantiated converter.  Works
-     * for complex as well as simple types.
-     * @example `Infer<typeof Converters.mapOf(Converters.stringArray)>` is `Map<string, string[]>`
-     * @beta
+     * {@inheritdoc Validation.Validator.withConstraint}
      */
-    declare type Infer<TCONV> = TCONV extends Converter<infer TTO> ? InnerInferredType<TTO> : never;
-
+    withConstraint(constraint: Constraint<T>, trait?: ConstraintTrait): Validator<T, TC>;
     /**
-     * @public
+     * {@inheritdoc Validation.Validator.brand}
      */
-    declare class InMemoryLogger extends LoggerBase {
-        protected _messages: string[];
-        protected _silent: string[];
-        constructor(logLevel?: LogLevel);
-        get messages(): string[];
-        get silent(): string[];
-        clear(): void;
-        protected _innerLog(message: string): Success<string | undefined>;
-        protected _innerSilent(message: string): Success<string | undefined>;
-    }
-
+    withBrand<B extends string>(brand: B): Validator<Brand<T, B>, TC>;
     /**
-     * internal
+     * Gets a default or explicit context.
+     * @param explicitContext - Optional explicit context.
+     * @returns The appropriate context to use.
+     * @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;
+    protected _context(explicitContext?: TC): TC | undefined;
+}
 
-    /**
-     * Represents the result of some operation of sequence of operations.
-     * @remarks
-     * This common contract enables commingled 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.
-         *
-         * Note that `getValueOrThrow` is being superseded by `orThrow` and
-         * will eventually be deprecated.  Please use orDefault instead.
-         *
-         * @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`).
-         *
-         * Note that `getValueOrDefault` is being superseded by `orDefault` and
-         * will eventually be deprecated.  Please use orDefault instead.
-         *
-         * @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;
-        /**
-         * 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.
-         */
-        orThrow(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.
-         */
-        orDefault(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
-         * appropriate added detail.
-         */
-        withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;
-    }
+/**
+ * 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>;
+}
 
-    /**
-     * Simple logger interface used by {@link IResult.orThrow}.
-     * @public
-     */
-    export declare interface IResultLogger {
-        /**
-         * Log an error message.
-         * @param message - The message to be logged.
-         */
-        error(message: string): void;
-    }
+/**
+ * Gets the type of a property specified by key from an arbitrary object.
+ * @param key - The key specifying the property to be tested.
+ * @param item - The object from which the property is to be tested.
+ * @returns The type of the requested property, or `undefined` if the
+ * property does not exist.
+ * @example
+ * Returns `'undefined'` (a string) if the property exists but has the value
+ * undefined but `undefined` (the literal) if the property does not exist.
+ * @public
+ */
+export declare function getTypeOfProperty<T extends object>(key: string | number | symbol, item: T): 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'undefined' | 'object' | 'function' | undefined;
 
-    /**
-     * Helper function to create a {@link Converter} from a supplied type guard function.
-     * @param description - a description of the thing to be validated for use in error messages
-     * @param guard - a {@link Validation.TypeGuardWithContext} which performs the validation.
-     * @returns A new {@link Converter} which validates the values using the supplied type guard
-     * and returns them in place.
-     * @public
-     */
-    declare function isA<T, TC = unknown>(description: string, guard: TypeGuardWithContext<T, TC>): Converter<T, TC>;
+/**
+ * Gets the value of a property specified by key from an arbitrary object,
+ * or a default value if the property does not exist.
+ * @param key - The key specifying the property to be retrieved.
+ * @param item - The object from which the property is to be retrieved.
+ * @param defaultValue - An optional default value to be returned if the property
+ * is not present (default `undefined`).
+ * @returns The value of the requested property, or the default value if the
+ * requested property does not exist.
+ * @public
+ */
+export declare function getValueOfPropertyOrDefault<T extends object>(key: string | number | symbol, item: T, defaultValue?: unknown): unknown | undefined;
 
-    /**
-     * Helper function to create a {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator} which
-     * validates a value or object in place.
-     * @param description - a description of the thing to be validated for use in error messages
-     * @param guard - a {@link Validation.TypeGuardWithContext} which performs the validation.
-     * @returns A new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator } which validates
-     * the values using the supplied type guard.
-     * @public
-     */
-    declare function isA_2<T, TC>(description: string, guard: TypeGuardWithContext<T, TC>, params?: Omit<TypeGuardValidatorConstructorParams<T, TC>, 'description' | 'guard'>): TypeGuardValidator<T, TC>;
+/**
+ * Infers the type that will be returned by an instantiated converter.  Works
+ * for complex as well as simple types.
+ * @example `Infer<typeof Converters.mapOf(Converters.stringArray)>` is `Map<string, string[]>`
+ * @beta
+ */
+declare type Infer<TCONV> = TCONV extends Converter<infer TTO> ? InnerInferredType<TTO> : never;
+
+/**
+ * @public
+ */
+declare class InMemoryLogger extends LoggerBase {
+    protected _messages: string[];
+    protected _silent: string[];
+    constructor(logLevel?: LogLevel);
+    get messages(): string[];
+    get silent(): string[];
+    clear(): void;
+    protected _innerLog(message: string): Success<string | undefined>;
+    protected _innerSilent(message: string): Success<string | undefined>;
+}
+
+/**
+ * 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 commingled discriminated usage of {@link Success | Success<T>}
+ * and {@link Failure | Failure<T>}.
+ * @public
+ */
+export declare interface IResult<T> {
     /**
-     * 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
+     * Indicates whether the operation was successful.
      */
-    export declare function isKeyOf<T extends object>(key: string | number | symbol, item: T): key is keyof T;
-
+    readonly success: boolean;
     /**
-     * A {@link Converter} which converts an iso formatted string, a number or a `Date` object to
-     * a `Date` object.
-     * @public
+     * Indicates whether this operation was successful.  Functions
+     * as a type guard for {@link Success | Success<T>}.
      */
-    declare const isoDate: Converter<Date, unknown>;
-
+    isSuccess(): this is Success<T>;
     /**
-     * @public
+     * Indicates whether this operation failed.  Functions
+     * as a type guard for {@link Failure | Failure<T>}.
      */
-    declare type JarFieldPicker<T extends JarRecord = JarRecord> = (record: T) => (keyof T)[];
-
+    isFailure(): this is Failure<T>;
     /**
-     * Represents a single record in a JAR file
-     * @public
+     * Gets the value associated with a successful {@link IResult | result},
+     * or throws the error message if the corresponding operation failed.
+     *
+     * Note that `getValueOrThrow` is being superseded by `orThrow` and
+     * will eventually be deprecated.  Please use orDefault instead.
+     *
+     * @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.
+     * @deprecated Use {@link IResult.orThrow | orThrow} instead.
+     */
+    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`).
+     *
+     * Note that `getValueOrDefault` is being superseded by `orDefault` and
+     * will eventually be deprecated.  Please use orDefault instead.
+     *
+     * @returns The return value, if the operation was successful.  Returns
+     * the supplied default value or `undefined` if no default is supplied.
+     * @deprecated Use {@link IResult.orDefault | orDefault} instead.
      */
-    declare type JarRecord = Record<string, string | string[]>;
-
+    getValueOrDefault(dflt?: T): T | undefined;
     /**
-     * Options for a JAR record parser.
-     * @public
+     * 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.
      */
-    declare interface JarRecordParserOptions {
-        readonly arrayFields?: string[] | JarFieldPicker;
-        readonly fixedContinuationSize?: number;
-    }
-
+    orThrow(logger?: IResultLogger): T;
     /**
-     * Options for {@link Converters.(recordOf:3) | Converters.recordOf} and
-     * {@link Converters.(mapOf:3) | Converters.mapOf}
-     * helper functions.
-     * @public
+     * 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.
+     * @returns The return value, if the operation was successful.  Returns
+     * the supplied default if an error occurred.
      */
-    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>;
-    }
-
+    orDefault(dflt: T): T;
     /**
-     * Type for factory methods which convert a key-value pair to a new unique value.
-     * @public
+     * Gets the value associated with a successful {@link IResult | result},
+     * or a default value if the corresponding operation failed.
+     * @returns The return value, if the operation was successful, or
+     * `undefined` if an error occurs.
      */
-    declare type KeyedThingFactory<TS, TD, TK extends string = string> = (key: TK, thing: TS) => Result<TD>;
-
+    orDefault(): T | undefined;
     /**
-     * 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
+     * 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.
      */
-    declare function literal<T>(value: T): Converter<T, unknown>;
-
+    onFailure(cb: FailureContinuation<T>): Result<T>;
     /**
-     * Helper function to create a {@link Validation.Validator} which validates a literal value.
-     * @param value - the literal value to be validated
-     * @public
+     * 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).
      */
-    declare function literal_2<T extends string | number | boolean | symbol | null | undefined>(value: T): Validator<T>;
-
+    withFailureDetail<TD>(detail: TD): DetailedResult<T, TD>;
     /**
-     * @public
+     * 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
+     * appropriate added detail.
      */
-    declare interface Logger {
-        log(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-        detail(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-        info(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-        warn(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-        warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
-        error<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
-    }
+    withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;
+}
 
+/**
+ * Simple logger interface used by {@link IResult.orThrow}.
+ * @public
+ */
+export declare interface IResultLogger {
     /**
-     * @public
+     * Log an error message.
+     * @param message - The message to be logged.
      */
-    declare abstract class LoggerBase {
-        logLevel: LogLevel;
-        constructor(logLevel?: LogLevel);
-        detail(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-        info(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-        warn(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-        warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
-        error<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
-        log(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-        protected _format(message?: unknown, ...parameters: unknown[]): string;
-        protected _innerSilent(__message: string): Success<string | undefined>;
-        protected abstract _innerLog(message: string): Success<string | undefined>;
-    }
+    error(message: string): void;
+}
 
-    declare namespace Logging {
-        export {
-            LogLevel,
-            Logger,
-            LoggerBase,
-            InMemoryLogger,
-            NoOpLogger
-        }
-    }
-    export { Logging }
+/**
+ * Helper function to create a {@link Converter} from a supplied type guard function.
+ * @param description - a description of the thing to be validated for use in error messages
+ * @param guard - a {@link Validation.TypeGuardWithContext} which performs the validation.
+ * @returns A new {@link Converter} which validates the values using the supplied type guard
+ * and returns them in place.
+ * @public
+ */
+declare function isA<T, TC = unknown>(description: string, guard: TypeGuardWithContext<T, TC>): Converter<T, TC>;
+
+/**
+ * Helper function to create a {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator} which
+ * validates a value or object in place.
+ * @param description - a description of the thing to be validated for use in error messages
+ * @param guard - a {@link Validation.TypeGuardWithContext} which performs the validation.
+ * @returns A new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator } which validates
+ * the values using the supplied type guard.
+ * @public
+ */
+declare function isA_2<T, TC>(description: string, guard: TypeGuardWithContext<T, TC>, params?: Omit<TypeGuardValidatorConstructorParams<T, TC>, 'description' | 'guard'>): TypeGuardValidator<T, TC>;
+
+/**
+ * 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: Converter<Date, unknown>;
 
+/**
+ * Options for {@link Converters.(recordOf:3) | Converters.recordOf} and
+ * {@link Converters.(mapOf:3) | Converters.mapOf}
+ * helper functions.
+ * @public
+ */
+declare interface KeyedConverterOptions<T extends string = string, TC = undefined> {
     /**
-     * @public
+     * 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.
      */
-    declare type LogLevel = 'detail' | 'info' | 'warning' | 'error' | 'silent';
-
+    onError?: 'fail' | 'ignore';
     /**
-     * Aggregates successful 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
-         * succeeded 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 messages.
-         * @public
-         */
-     export declare function mapDetailedResults<T, TD>(results: Iterable<DetailedResult<T, TD>>, ignore: TD[]): Result<T[]>;
+     * 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>;
+}
 
-     /**
-      * Aggregates error messages from a collection of {@link Result | Result<T>}.
-      * @param results - An iterable 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 WITH_DEFAULT}
-      * @public
-      */
-     declare function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>): Converter<Map<TK, 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>;
 
-     /**
-      * 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 WITH_ON_ERROR}
-      * @public
-      */
-     declare function mapOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, onError: 'fail' | 'ignore'): Converter<Map<TK, T>, TC>;
+/**
+ * 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>;
 
-     /**
-      * 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 WITH_OPTIONS}
-      * @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 Validation.Validator} which validates a literal value.
+ * @param value - the literal value to be validated
+ * @public
+ */
+declare function literal_2<T extends string | number | boolean | symbol | null | undefined>(value: T): Validator<T>;
 
-     /**
-      * 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>;
+/**
+ * @public
+ */
+declare interface Logger {
+    log(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    detail(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    info(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    warn(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
+    error<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
+}
 
-     /**
-      * Aggregates successful 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[]>;
+/**
+ * @public
+ */
+declare abstract class LoggerBase {
+    logLevel: LogLevel;
+    constructor(logLevel?: LogLevel);
+    detail(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    info(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    warn(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
+    error<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
+    log(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    protected _format(message?: unknown, ...parameters: unknown[]): string;
+    protected _innerSilent(__message: string): Success<string | undefined>;
+    protected abstract _innerLog(message: string): Success<string | undefined>;
+}
 
-     /**
-      * 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[]>;
+declare namespace Logging {
+    export {
+        LogLevel,
+        Logger,
+        LoggerBase,
+        InMemoryLogger,
+        NoOpLogger
+    }
+}
+export { Logging }
 
-      /**
-       * Applies a factory method to convert a `ReadonlyMap<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: ReadonlyMap<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
+/**
+ * @public
+ */
+declare type LogLevel = 'detail' | 'info' | 'warning' | 'error' | 'silent';
 
+/**
+ * Aggregates successful 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
+     * succeeded 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 messages.
+     * @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 iterable 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 WITH_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 WITH_ON_ERROR}
+  * @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 WITH_OPTIONS}
+  * @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 successful 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 `ReadonlyMap<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: ReadonlyMap<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
+
+   /**
+    * @public
+    */
+   declare class NoOpLogger extends LoggerBase {
+       protected _innerLog(message: string): Success<string | undefined>;
+   }
+
+   /**
+    * Normalizes an arbitrary JSON object
+    * @public
+    */
+   export declare class Normalizer {
        /**
-        * @public
+        * Normalizes the supplied value
+        *
+        * @param from - The value to be normalized
+        * @returns A normalized version of the value
         */
-       declare class NoOpLogger extends LoggerBase {
-           protected _innerLog(message: string): Success<string | undefined>;
-       }
-
+       normalize<T>(from: T): Result<T>;
        /**
-        * Normalizes an arbitrary JSON object
-        * @public
+        * 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
         */
-       export declare class Normalizer {
-           /**
-            * Normalizes the supplied value
-            *
-            * @param from - The value to be normalized
-            * @returns A normalized version of the value
-            */
-           normalize<T>(from: T): Result<T>;
-           /**
-            * 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<T = unknown>(entries: Iterable<Entry<T>>): Entry<T>[];
-           protected _normalizeArray(from: unknown[]): Result<unknown[]>;
-           /**
-            * Normalizes the supplied literal value
-            * @param from - The literal value to be normalized.
-            * @returns A normalized value for the literal.
-            * @internal
-            */
-           protected _normalizeLiteral<T>(from: T): Result<T>;
-       }
-
+       protected _compareKeys(k1: unknown, k2: unknown): number;
        /**
-        * Computes a normalized hash for an arbitrary javascript value.
-        * @public
+        * 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
         */
-       declare class Normalizer_2 {
-           /**
-            * 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>;
-       }
-
+       protected _normalizeEntries<T = unknown>(entries: Iterable<Entry<T>>): Entry<T>[];
+       protected _normalizeArray(from: unknown[]): Result<unknown[]>;
        /**
-        * A {@link Converter} which converts `unknown` to a `number`.
-        * @remarks
-        * Numbers and strings with a numeric format succeed. Anything else fails.
-        * @public
+        * Normalizes the supplied literal value
+        * @param from - The literal value to be normalized.
+        * @returns A normalized value for the literal.
+        * @internal
         */
-       declare const number: Converter<number, undefined>;
-
+       protected _normalizeLiteral<T>(from: T): Result<T>;
+   }
+
+   /**
+    * 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: Converter<number, undefined>;
+
+   /**
+    * A {@link Validation.Classes.NumberValidator | NumberValidator} which validates a number in place.
+    * @public
+    */
+   declare const number_2: Validator<number>;
+
+   /**
+    * {@link Converter | Converter} to convert an `unknown` to an array of `number`.
+    * @remarks
+    * Returns {@link Success | Success} with the the supplied value if it as an array
+    * of numbers, returns {@link Failure | Failure} with an error message otherwise.
+    * @public
+    */
+   declare const numberArray: Converter<number[]>;
+
+   /**
+    * An in-place {@link Validation.Validator | Validator} for `number` values.
+    * @public
+    */
+   declare class NumberValidator<T extends number = number, TC = unknown> extends GenericValidator<T, TC> {
        /**
-        * A {@link Validation.Classes.NumberValidator | NumberValidator} which validates a number in place.
-        * @public
+        * 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}.
         */
-       declare const number_2: Validator<number>;
-
+       constructor(params?: NumberValidatorConstructorParams<T, TC>);
        /**
-        * {@link Converter | Converter} to convert an `unknown` to an array of `number`.
-        * @remarks
-        * Returns {@link Success | Success} with the the supplied value if it as an array
-        * of numbers, returns {@link Failure | Failure} with an error message otherwise.
-        * @public
+        * 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.
         */
-       declare const numberArray: Converter<number[]>;
-
+       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 Conversion.ObjectConverter | ObjectConverter<T>} which converts an object
+    * without changing shape, given a {@link Conversion.FieldConverters | FieldConverters<T>} and an optional
+    * {@link Conversion.ObjectConverterOptions | ObjectConverterOptions<T>} to further refine conversion behavior.
+    * @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 required 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 Conversion.FieldConverters | FieldConverters<T>} defining the shape of the
+    * source object and {@link Converter | converters} to be applied to each properties.
+    * @param options - An {@link Conversion.ObjectConverterOptions | ObjectConverterOptions<T>} containing options
+    * for the object converter.
+    * @returns A new {@link Conversion.ObjectConverter | ObjectConverter} which applies the specified conversions.
+    * {@label WITH_OPTIONS}
+    * @public
+    */
+   declare function object<T>(properties: FieldConverters<T>, options?: ObjectConverterOptions<T>): ObjectConverter<T>;
+
+   /**
+    * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter<T>} which converts an object
+    * without changing shape, given a {@link Conversion.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 required 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 Conversion.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 WITH_KEYS}
+    * @returns A new {@link Conversion.ObjectConverter | ObjectConverter} which applies the specified conversions.
+    * @public
+    * @deprecated Use {@link Converters.(object:1) | 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 = unknown>(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 Conversion.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 Conversion.ObjectConverterOptions | ObjectConverterOptions}
+    * for other conversion options.
+    * @public
+    */
+   declare class ObjectConverter<T, TC = unknown> extends BaseConverter<T, TC> {
        /**
-        * An in-place {@link Validation.Validator | Validator} for `number` values.
-        * @public
+        * Fields converted by this {@link Conversion.ObjectConverter | ObjectConverter}.
         */
-       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>;
-       }
-
+       readonly fields: FieldConverters<T>;
        /**
-        * Parameters used to construct a {@link Validation.Classes.NumberValidator | NumberValidator}.
-        * @public
+        * Options used to initialize this {@link Conversion.ObjectConverter | ObjectConverter}.
         */
-       declare type NumberValidatorConstructorParams<T extends number = number, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
-
+       readonly options: ObjectConverterOptions<T>;
        /**
-        * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter<T>} which converts an object
-        * without changing shape, given a {@link Conversion.FieldConverters | FieldConverters<T>} and an optional
-        * {@link Conversion.ObjectConverterOptions | ObjectConverterOptions<T>} to further refine conversion behavior.
-        * @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 required 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 Conversion.FieldConverters | FieldConverters<T>} defining the shape of the
-        * source object and {@link Converter | converters} to be applied to each properties.
-        * @param options - An {@link Conversion.ObjectConverterOptions | ObjectConverterOptions<T>} containing options
-        * for the object converter.
-        * @returns A new {@link Conversion.ObjectConverter | ObjectConverter} which applies the specified conversions.
+        * Constructs a new {@link Conversion.ObjectConverter | ObjectConverter<T>} using options
+        * supplied in a {@link Conversion.ObjectConverterOptions | ObjectConverterOptions<T>}.
+        * @param fields - A {@link Conversion.FieldConverters | FieldConverters<T>} containing
+        * a {@link Converter} for each field
+        * @param options - An optional @see ObjectConverterOptions to configure the conversion
         * {@label WITH_OPTIONS}
-        * @public
         */
-       declare function object<T>(properties: FieldConverters<T>, options?: ObjectConverterOptions<T>): ObjectConverter<T>;
-
+       constructor(fields: FieldConverters<T, TC>, options?: ObjectConverterOptions<T>);
        /**
-        * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter<T>} which converts an object
-        * without changing shape, given a {@link Conversion.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 required 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 Conversion.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.
+        * Constructs a new {@link Conversion.ObjectConverter | ObjectConverter<T>} with optional
+        * properties specified as an array of `keyof T`.
+        * @param fields - A {@link Conversion.FieldConverters | FieldConverters<T>} containing
+        * a {@link Converter} for each field.
+        * @param optional - An array of `keyof T` listing fields that are not required.
         * {@label WITH_KEYS}
-        * @returns A new {@link Conversion.ObjectConverter | ObjectConverter} which applies the specified conversions.
-        * @public
-        * @deprecated Use {@link Converters.(object:1) | Converters.object(fields, options)} instead.
         */
-       declare function object<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;
-
+       constructor(fields: FieldConverters<T, TC>, optional?: (keyof T)[]);
+       /**
+        * Creates a new {@link Conversion.ObjectConverter | ObjectConverter} derived from this one but with
+        * new optional properties as specified by a supplied {@link Conversion.ObjectConverterOptions | ObjectConverterOptions<T>}.
+        * @param options - The {@link Conversion.ObjectConverterOptions | options} to be applied to the new
+        * converter.
+        * @returns A new {@link Conversion.ObjectConverter | ObjectConverter} with the additional optional source properties.
+        * {@label WITH_OPTIONS}
+        */
+       partial(options: ObjectConverterOptions<T>): ObjectConverter<Partial<T>, TC>;
+       /**
+        * Creates a new {@link Conversion.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 Conversion.ObjectConverter | ObjectConverter} with the additional optional source
+        * properties.
+        * {@label WITH_KEYS}
+        */
+       partial(optional?: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
+       /**
+        * Creates a new {@link Conversion.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 Conversion.ObjectConverter | ObjectConverter} with the additional optional source
+        * properties.
+        */
+       addPartial(addOptionalProperties: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
+   }
+
+   /**
+    * Options for an {@link Conversion.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;
+       /**
+        * Optional description to be included in error messages.
+        */
+       description?: string;
+   }
+
+   /**
+    * 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>;
        /**
-        * 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.
+        * @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;
+   }
+
+   /**
+    * Simple implicit omit function, which picks all of the properties from a supplied
+    * object except those specified for exclusion.
+    * @param from - The object from which keys are to be picked.
+    * @param exclude - The keys of the properties to be excluded from the returned object.
+    * @returns A new object containing all of the properties from `from` that were not
+    * explicitly excluded.
+    * @public
+    */
+   export declare function omit<T extends object, K extends keyof T>(from: T, exclude: K[]): Omit<T, K>;
+
+   /**
+    * 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 unconvertible 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';
+
+   /**
+    * Action to take on conversion failures.
+    * @public
+    */
+   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>;
+
+   /**
+    * 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 exists
+    * 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 corresponding
+    * object property if the field exists and can be converted. Returns {@link Success} with value `undefined`
+    * if the supplied parameter 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 `ReadonlyMap<string, TS>` into a `Record<string, TD>`
+    * @param src - The `ReadonlyMap` 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
         */
-       declare function object_2<T, TC = unknown>(fields: FieldValidators<T, TC>, params?: Omit<ObjectValidatorConstructorParams<T, TC>, 'fields'>): ObjectValidator<T, TC>;
+    export declare function optionalMapToPossiblyEmptyRecord<TS, TD, TK extends string = string>(src: ReadonlyMap<TK, TS> | undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
+
+    /**
+     * Applies a factory method to convert an optional `ReadonlyMap<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: ReadonlyMap<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>;
+
+     /**
+      * 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 object of type `<T>` without changing shape, given
-        * a {@link Conversion.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 Conversion.ObjectConverterOptions | ObjectConverterOptions}
-        * for other conversion options.
+        * 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 class ObjectConverter<T, TC = unknown> extends BaseConverter<T, TC> {
-           /**
-            * Fields converted by this {@link Conversion.ObjectConverter | ObjectConverter}.
-            */
-           readonly fields: FieldConverters<T>;
-           /**
-            * Options used to initialize this {@link Conversion.ObjectConverter | ObjectConverter}.
-            */
-           readonly options: ObjectConverterOptions<T>;
-           /**
-            * Constructs a new {@link Conversion.ObjectConverter | ObjectConverter<T>} using options
-            * supplied in a {@link Conversion.ObjectConverterOptions | ObjectConverterOptions<T>}.
-            * @param fields - A {@link Conversion.FieldConverters | FieldConverters<T>} containing
-            * a {@link Converter} for each field
-            * @param options - An optional @see ObjectConverterOptions to configure the conversion
-            * {@label WITH_OPTIONS}
-            */
-           constructor(fields: FieldConverters<T, TC>, options?: ObjectConverterOptions<T>);
-           /**
-            * Constructs a new {@link Conversion.ObjectConverter | ObjectConverter<T>} with optional
-            * properties specified as an array of `keyof T`.
-            * @param fields - A {@link Conversion.FieldConverters | FieldConverters<T>} containing
-            * a {@link Converter} for each field.
-            * @param optional - An array of `keyof T` listing fields that are not required.
-            * {@label WITH_KEYS}
-            */
-           constructor(fields: FieldConverters<T, TC>, optional?: (keyof T)[]);
-           /**
-            * Creates a new {@link Conversion.ObjectConverter | ObjectConverter} derived from this one but with
-            * new optional properties as specified by a supplied {@link Conversion.ObjectConverterOptions | ObjectConverterOptions<T>}.
-            * @param options - The {@link Conversion.ObjectConverterOptions | options} to be applied to the new
-            * converter.
-            * @returns A new {@link Conversion.ObjectConverter | ObjectConverter} with the additional optional source properties.
-            * {@label WITH_OPTIONS}
-            */
-           partial(options: ObjectConverterOptions<T>): ObjectConverter<Partial<T>, TC>;
-           /**
-            * Creates a new {@link Conversion.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 Conversion.ObjectConverter | ObjectConverter} with the additional optional source
-            * properties.
-            * {@label WITH_KEYS}
-            */
-           partial(optional?: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
-           /**
-            * Creates a new {@link Conversion.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 Conversion.ObjectConverter | ObjectConverter} with the additional optional source
-            * properties.
-            */
-           addPartial(addOptionalProperties: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
-       }
+       declare const optionalString: Converter<string | undefined, unknown>;
 
        /**
-        * Options for an {@link Conversion.ObjectConverter | ObjectConverter}.
+        * Simple implicit pick function, which picks a set of properties from a supplied
+        * object.  Ignores picked properties that do not exist regardless of type signature.
+        * @param from - The object from which keys are to be picked.
+        * @param include - The keys of the properties to be picked from `from`.
+        * @returns A new object containing the requested properties from `from`, where present.
         * @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;
-           /**
-            * Optional description to be included in error messages.
-            */
-           description?: string;
-       }
+       export declare function pick<T extends object, K extends keyof T>(from: T, include: K[]): Pick<T, K>;
 
        /**
-        * 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.
+        * 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.
+        * @param options - An optional {@link PopulateObjectOptions | set of options} which
+        * modify the behavior of this call.
+        * {@label WITH_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>;
-       }
+       export declare function populateObject<T>(initializers: FieldInitializers<T>, options?: PopulateObjectOptions<T>): Result<T>;
 
        /**
-        * Options for the {@link Validation.Classes.ObjectValidator | ObjectValidator} constructor.
+        * 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.
+        * @param order - Optional order in which keys should be written.
         * @public
+        * {@label WITH_ORDER}
+        * @deprecated Pass {@link PopulateObjectOptions} instead.
         */
-       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>;
-       }
+       export declare function populateObject<T>(initializers: FieldInitializers<T>, order: (keyof T)[]): Result<T>;
 
        /**
-        * Options for an {@link Validation.Classes.ObjectValidator | ObjectValidator}.
+        * Options for the {@link (populateObject:1)} function.
         * @public
         */
-       declare interface ObjectValidatorOptions<T, TC> extends ValidatorOptions<TC> {
+       export declare interface PopulateObjectOptions<T> {
            /**
-            * If present, lists optional fields. Missing non-optional fields cause an error.
+            * If present, specifies the order in which property values should
+            * be evaluated.  Any keys not listed are evaluated after all listed
+            * keys in indeterminate order.  If 'order' is not present, keys
+            * are evaluated in indeterminate order.
             */
-           optionalFields?: (keyof T)[];
+           order?: (keyof T)[];
            /**
-            * If true, unrecognized fields yield an error.  If false or undefined (default),
-            * unrecognized fields are ignored.
+            * Specify handling of `undefined` values.  By default, successful
+            * `undefined` results are written to the result object.  If this value
+            * is `true` then `undefined` results are suppressed for all properties.
+            * If this value is an array of property keys then `undefined` results
+            * are suppressed for those properties only.
             */
-           strict?: boolean;
+           suppressUndefined?: boolean | (keyof T)[];
        }
 
        /**
-        * Simple implicit omit function, which picks all of the properties from a supplied
-        * object except those specified for exclusion.
-        * @param from - The object from which keys are to be picked.
-        * @param exclude - The keys of the properties to be excluded from the returned object.
-        * @returns A new object containing all of the properties from `from` that were not
-        * explicitly excluded.
-        * @public
-        */
-       export declare function omit<T extends object, K extends keyof T>(from: T, exclude: K[]): Omit<T, K>;
-
-       /**
-        * 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 unconvertible elements.
-        * @returns A new {@link Converter} which yields a value from the union of the types returned
-        * by the wrapped converters.
+        * 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
         */
-       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';
+       export declare function propagateWithDetail<T, TD>(result: Result<T>, detail: TD, successDetail?: TD): DetailedResult<T, TD>;
 
        /**
-        * A {@link Converter} to convert an optional `boolean` value.
+        * 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
-        * 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`.
+        * 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 WITH_DEFAULT}
         * @public
         */
-       declare const optionalBoolean: Converter<boolean | undefined>;
+       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 extracts and converts an optional element from an array.
+        * 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
-        * The resulting {@link Converter} returns {@link Success} with the converted value if the element exists
-        * 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.
+        * 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 WITH_ON_ERROR}
         * @public
         */
-       declare function optionalElement<T, TC = undefined>(index: number, converter: Converter<T, TC>): Converter<T | undefined, TC>;
+       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 extracts and convert a property specified
-        * by name from an object.
+        * 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
-        * The resulting {@link Converter} returns {@link Success} with the converted value of the corresponding
-        * object property if the field exists and can be converted. Returns {@link Success} with value `undefined`
-        * if the supplied parameter 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.
+        * 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 WITH_OPTIONS}
         * @public
         */
-       declare function optionalField<T, TC = undefined>(name: string, converter: Converter<T, TC>): Converter<T | undefined, TC>;
+       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 an optional `ReadonlyMap<string, TS>` into a `Record<string, TD>`
-        * @param src - The `ReadonlyMap` object to be converted, or `undefined`.
+        * 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 record (empty if `src` is `undefined`) if conversion succeeds.
-            * Returns {@link Failure} with a message if an error occurs.
+        * @returns {@link Success} with the resulting map on success, or {@link Failure} with a
+            * message if an error occurs.
             * @public
             */
-        export declare function optionalMapToPossiblyEmptyRecord<TS, TD, TK extends string = string>(src: ReadonlyMap<TK, TS> | undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
+        export declare function recordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>>;
 
         /**
-         * Applies a factory method to convert an optional `ReadonlyMap<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: ReadonlyMap<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>;
-
-         /**
-          * 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>>;
+         * 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 commingled discriminated usage.
+         * @public
+         */
+        export declare type Result<T> = Success<T> | Failure<T>;
 
-           /**
-            * 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>;
+        /**
+         * 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;
 
-           /**
-            * Reads a record-jar from an array of strings, each of which represents one
-            * line in the source file.
-            * @param lines - the array of strings to be parsed
-            * @param options - Optional parser configuration
-            * @returns a corresponding array of `Record<string, string>`
-            * @public
-            */
-           declare function parseRecordJarLines(lines: string[], options?: JarRecordParserOptions): Result<JarRecord[]>;
+        /**
+         * Type inference to determine the result type of an {@link Result}.
+         * @beta
+         */
+        export declare type ResultValueType<T> = T extends Result<infer TV> ? TV : never;
 
-           /**
-            * Simple implicit pick function, which picks a set of properties from a supplied
-            * object.  Ignores picked properties that do not exist regardless of type signature.
-            * @param from - The object from which keys are to be picked.
-            * @param include - The keys of the properties to be picked from `from`.
-            * @returns A new object containing the requested properties from `from`, where present.
-            * @public
-            */
-           export declare function pick<T extends object, K extends keyof T>(from: T, include: K[]): Pick<T, K>;
+        /**
+         * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter} which converts an object
+         * without changing shape, a {@link Conversion.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 Conversion.ObjectConverter | ObjectConverter} which applies the specified conversions.
+         * {@label WITH_OPTIONS}
+         * @public
+         */
+        declare function strictObject<T>(properties: FieldConverters<T>, options?: StrictObjectConverterOptions<T>): ObjectConverter<T>;
 
-           /**
-            * 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.
-            * @param options - An optional {@link PopulateObjectOptions | set of options} which
-            * modify the behavior of this call.
-            * {@label WITH_OPTIONS}
-            * @public
-            */
-           export declare function populateObject<T>(initializers: FieldInitializers<T>, options?: PopulateObjectOptions<T>): Result<T>;
-
-           /**
-            * 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.
-            * @param order - Optional order in which keys should be written.
-            * @public
-            * {@label WITH_ORDER}
-            * @deprecated Pass {@link PopulateObjectOptions} instead.
-            */
-           export declare function populateObject<T>(initializers: FieldInitializers<T>, order: (keyof T)[]): Result<T>;
-
-           /**
-            * Options for the {@link (populateObject:1)} function.
-            * @public
-            */
-           export declare interface PopulateObjectOptions<T> {
-               /**
-                * If present, specifies the order in which property values should
-                * be evaluated.  Any keys not listed are evaluated after all listed
-                * keys in indeterminate order.  If 'order' is not present, keys
-                * are evaluated in indeterminate order.
-                */
-               order?: (keyof T)[];
-               /**
-                * Specify handling of `undefined` values.  By default, successful
-                * `undefined` results are written to the result object.  If this value
-                * is `true` then `undefined` results are suppressed for all properties.
-                * If this value is an array of property keys then `undefined` results
-                * are suppressed for those properties only.
-                */
-               suppressUndefined?: boolean | (keyof 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
-            */
-           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 Experimental.RangeOf | RangeOf<T>}.
-                * @param min - Optional minimum extent of the range.
-                * @param max - Optional maximum extent of the range.
-                */
-               constructor(min?: T, max?: T);
-               /**
-                * Static constructor for a {@link Experimental.RangeOf | RangeOf<T>}.
-                * @param init - {@link Experimental.RangeOfProperties | Range initializer}.
-                * @returns A new {@link Experimental.RangeOf | RangeOf<T>}.
-                */
-               static createRange<T>(init?: RangeOfProperties<T>): Result<RangeOf<T>>;
-               /**
-                * Gets a formatted description of a {@link Experimental.RangeOfProperties | RangeOfProperties<T>} given an
-                * optional set of formats and 'empty' value to use.
-                * @param range - The {@link Experimental.RangeOfProperties | RangeOfProperties<T>} to be formatted.
-                * @param formats - Optional {@link Experimental.RangeOfFormats | formats} to use. Default is
-                * {@link Experimental.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 Experimental.RangeOfProperties | RangeOfProperties<string>} containing the
-                * formatted representation of the {@link Experimental.RangeOf.min | minimum} and
-                * {@link Experimental.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 maximum extent values.
-                * @param formats - The {@link Experimental.RangeOfFormats | format strings} used to format the range
-                * (default {@link Experimental.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 overridden 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 Experimental.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 Experimental.RangeOf | RangeOf<T>}.
-            * @public
-            */
-           declare interface RangeOfFormats {
-               minOnly: string;
-               maxOnly: string;
-               minMax: string;
-           }
-
-           /**
-            * Represents a generic range of some comparable type `<T>`.
-            * @public
-            */
-           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.
-            * @param options - optional parameters to control the processing
-            * @returns The contents of the file.
-            * @beta
-            */
-           declare function readCsvFileSync(srcPath: string, options?: CsvOptions): Result<unknown>;
-
-           /**
-            * Reads a record-jar file from a supplied path.
-            * @param srcPath - Source path from which the file is read.
-            * @param options - Optional parser configuration
-            * @returns The contents of the file as an array of `Record<string, string>`
-            * @see https://datatracker.ietf.org/doc/html/draft-phillips-record-jar-01
-            * @public
-            */
-           declare function readRecordJarFileSync(srcPath: string, options?: JarRecordParserOptions): Result<JarRecord[]>;
-
-           declare namespace RecordJar {
-               export {
-                   parseRecordJarLines,
-                   readRecordJarFileSync,
-                   JarRecord,
-                   JarFieldPicker,
-                   JarRecordParserOptions
-               }
-           }
-           export { RecordJar }
+        /**
+         * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter} which converts an object
+         * without changing shape, a {@link Conversion.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 Conversion.ObjectConverter | ObjectConverter} which applies the specified conversions.
+         * {@label WITH_KEYS}
+         * @deprecated Use {@link Converters.(strictObject:1) | Converters.strictObject(options)} instead.
+         * @public
+         */
+        declare function strictObject<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;
 
-           /**
-            * 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 WITH_DEFAULT}
-            * @public
-            */
-           declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>): Converter<Record<TK, T>, TC>;
+        /**
+         * Options for the {@link Converters.(strictObject:1)} helper function.
+         * @public
+         */
+        declare type StrictObjectConverterOptions<T> = Omit<ObjectConverterOptions<T>, 'strict'>;
 
-           /**
-            * 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 WITH_ON_ERROR}
-            * @public
-            */
-           declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, onError: 'fail' | 'ignore'): Converter<Record<TK, T>, TC>;
+        /**
+         * A converter to convert unknown to string. Values of type
+         * string succeed.  Anything else fails.
+         * @public
+         */
+        declare const string: StringConverter;
 
-           /**
-            * 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 WITH_OPTIONS}
-            * @public
-            */
-           declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC>, options: KeyedConverterOptions<TK, TC>): Converter<Record<TK, T>, TC>;
+        /**
+         * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
+         * @public
+         */
+        declare const string_2: Validator<string>;
 
-           /**
-            * 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>>;
+        /**
+         * {@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[]>;
 
+        /**
+         * The {@link Conversion.StringConverter | StringConverter} class extends
+         * {@link Conversion.BaseConverter | BaseConverter} to provide string-specific
+         * helper methods.
+         * @public
+         */
+        declare class StringConverter<T extends string = string, TC = unknown> extends BaseConverter<T, TC> {
             /**
-             * 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 commingled discriminated usage.
-             * @public
+             * Construct a new {@link Conversion.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.
              */
-            export declare type Result<T> = Success<T> | Failure<T>;
-
+            constructor(defaultContext?: TC, traits?: ConverterTraits, converter?: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>);
             /**
-             * Type inference to determine the detail type `TD` of a {@link DetailedResult | DetailedResult<T, TD>}.
-             * @beta
+             * @internal
              */
-            export declare type ResultDetailType<T> = T extends DetailedResult<unknown, infer TD> ? TD : never;
-
+            protected static _convert<T extends string>(from: unknown): Result<T>;
             /**
-             * Type inference to determine the result type of an {@link Result}.
-             * @beta
+             * @internal
              */
-            export declare type ResultValueType<T> = T extends Result<infer TV> ? TV : never;
-
+            protected static _wrap<T extends string, TC>(wrapped: StringConverter<T, TC>, converter: (from: T) => Result<T>, traits?: ConverterTraits): StringConverter<T, TC>;
             /**
-             * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter} which converts an object
-             * without changing shape, a {@link Conversion.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 Conversion.ObjectConverter | ObjectConverter} which applies the specified conversions.
-             * {@label WITH_OPTIONS}
-             * @public
-             */
-            declare function strictObject<T>(properties: FieldConverters<T>, options?: StrictObjectConverterOptions<T>): ObjectConverter<T>;
+             * Returns a {@link Conversion.StringConverter | StringConverter} which constrains the result to match
+             * a supplied string.
+             * @param match - The string to be matched
+             * @param options - Optional {@link Conversion.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 WITH_STRING}
+                 */
+             matching(match: string, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+             /**
+              * Returns a {@link Conversion.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 Conversion.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 WITH_ARRAY}
+                  */
+              matching(match: string[], options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+              /**
+               * Returns a {@link Conversion.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 Conversion.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 WITH_SET}
+                   */
+               matching(match: Set<T>, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+               /**
+                * Returns a {@link Conversion.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 Conversion.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 WITH_REGEXP}
+                    */
+                matching(match: RegExp, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+               }
 
-            /**
-             * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter} which converts an object
-             * without changing shape, a {@link Conversion.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 Conversion.ObjectConverter | ObjectConverter} which applies the specified conversions.
-             * {@label WITH_KEYS}
-             * @deprecated Use {@link Converters.(strictObject:1) | Converters.strictObject(options)} instead.
-             * @public
-             */
-            declare function strictObject<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;
+               /**
+                * Options for {@link Conversion.StringConverter | StringConverter}
+                * matching method
+                * @public
+                */
+               declare interface StringMatchOptions {
+                   /**
+                    * An optional message to be displayed if a non-matching string
+                    * is encountered.
+                    */
+                   message?: string;
+               }
 
-            /**
-             * Options for the {@link Converters.(strictObject:1)} helper function.
-             * @public
-             */
-            declare type StrictObjectConverterOptions<T> = Omit<ObjectConverterOptions<T>, 'strict'>;
+               /**
+                * 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>;
+               }
 
-            /**
-             * A converter to convert unknown to string. Values of type
-             * string succeed.  Anything else fails.
-             * @public
-             */
-            declare const string: StringConverter;
+               /**
+                * Parameters used to construct a {@link Validation.Classes.StringValidator | StringValidator}.
+                * @public
+                */
+               declare type StringValidatorConstructorParams<T extends string = string, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
 
-            /**
-             * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
-             * @public
-             */
-            declare const string_2: Validator<string>;
+               /**
+                * 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>;
 
-            /**
-             * {@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[]>;
+               /**
+                * 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>;
 
-            /**
-             * The {@link Conversion.StringConverter | StringConverter} class extends
-             * {@link Conversion.BaseConverter | 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 Conversion.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 Conversion.StringConverter | StringConverter} which constrains the result to match
-                 * a supplied string.
-                 * @param match - The string to be matched
-                 * @param options - Optional {@link Conversion.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 WITH_STRING}
-                     */
-                 matching(match: string, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
-                 /**
-                  * Returns a {@link Conversion.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 Conversion.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 WITH_ARRAY}
-                      */
-                  matching(match: string[], options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
-                  /**
-                   * Returns a {@link Conversion.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 Conversion.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 WITH_SET}
-                       */
-                   matching(match: Set<T>, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
+               /**
+                * Reports a successful {@link IResult | result} from some operation and the
+                * corresponding value.
+                * @public
+                */
+               export declare class Success<T> implements IResult<T> {
                    /**
-                    * Returns a {@link Conversion.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 Conversion.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 WITH_REGEXP}
-                        */
-                    matching(match: RegExp, options?: Partial<StringMatchOptions>): StringConverter<T, TC>;
-                   }
-
+                    * {@inheritdoc IResult.success}
+                    */
+                   readonly success: true;
                    /**
-                    * Options for {@link Conversion.StringConverter | StringConverter}
-                    * matching method
-                    * @public
+                    * @internal
                     */
-                   declare interface StringMatchOptions {
-                       /**
-                        * An optional message to be displayed if a non-matching string
-                        * is encountered.
-                        */
-                       message?: string;
-                   }
-
+                   private readonly _value;
                    /**
-                    * An in-place {@link Validation.Validator | Validator} for `string` values.
-                    * @public
+                    * Constructs a {@link Success} with the supplied value.
+                    * @param value - The value to be returned.
                     */
-                   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>;
-                   }
-
+                   constructor(value: T);
                    /**
-                    * Parameters used to construct a {@link Validation.Classes.StringValidator | StringValidator}.
-                    * @public
+                    * The result value returned by the successful operation.
                     */
-                   declare type StringValidatorConstructorParams<T extends string = string, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
-
+                   get value(): T;
                    /**
-                    * Returns {@link Success | Success<T>} with the supplied result value.
-                    * @param value - The successful result value to be returned
-                    * @public
+                    * {@inheritdoc IResult.isSuccess}
                     */
-                   export declare function succeed<T>(value: T): Success<T>;
-
+                   isSuccess(): this is 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
+                    * {@inheritdoc IResult.isFailure}
                     */
-                   export declare function succeedWithDetail<T, TD>(value: T, detail?: TD): DetailedSuccess<T, TD>;
-
+                   isFailure(): this is Failure<T>;
                    /**
-                    * Reports a successful {@link IResult | result} from some operation and the
-                    * corresponding value.
-                    * @public
+                    * {@inheritdoc IResult.orThrow}
                     */
-                   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.orThrow}
-                        */
-                       orThrow(__logger?: IResultLogger): T;
-                       /**
-                        * {@inheritdoc IResult.orDefault}
-                        */
-                       orDefault(dflt?: T): T | undefined;
-                       /**
-                        * {@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>;
-                   }
-
+                   orThrow(__logger?: IResultLogger): T;
                    /**
-                    * Continuation callback to be called in the event that an
-                    * {@link Result} is successful.
-                    * @public
+                    * {@inheritdoc IResult.orDefault}
                     */
-                   export declare type SuccessContinuation<T, TN> = (value: T) => Result<TN>;
-
+                   orDefault(dflt: T): T;
+                   orDefault(): T | undefined;
                    /**
-                    * Helper function to create a {@link Conversion.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
+                    * {@inheritdoc IResult.getValueOrThrow}
+                    * @deprecated Use {@link Success.orThrow | orThrow} instead.
                     */
-                   declare function templateString(defaultContext?: unknown): StringConverter<string, unknown>;
-
+                   getValueOrThrow(__logger?: IResultLogger): T;
                    /**
-                    * 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 Conversion.FieldConverters | FieldConverter} which extracts and converts
-                    * a single filed from the source object.
-                    * @returns A {@link Converter} with the specified conversion behavior.
-                    * @public
+                    * {@inheritdoc IResult.getValueOrDefault}
+                    * @deprecated Use {@link Success.orDefault | orDefault} instead.
                     */
-                   declare function transform<T, TC = unknown>(properties: FieldConverters<T, TC>): Converter<T, TC>;
-
+                   getValueOrDefault(dflt?: T): T | undefined;
                    /**
-                    * Helper to create a strongly-typed {@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.
-                    *
-                    * @param destinationFields - An object with key names that correspond to the target object and an
-                    * appropriate {@link Converters.FieldTransformers | FieldTransformers} which specifies the name
-                    * of the corresponding property in the source object, the converter used to convert the source
-                    * property and any configuration to guide the conversion.
-                    * @param options - Options which affect the transformation.
-                    *
-                    * @returns A {@link Converter} with the specified conversion behavior.
-                    * @public
+                    * {@inheritdoc IResult.onSuccess}
                     */
-                   declare function transformObject<TSRC, TDEST, TC = unknown>(destinationFields: FieldTransformers<TSRC, TDEST, TC>, options?: TransformObjectOptions<TSRC>): Converter<TDEST, TC>;
-
+                   onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN>;
                    /**
-                    * Options for a {@link Converters.transformObject} call.
-                    * @public
+                    * {@inheritdoc IResult.onFailure}
                     */
-                   declare interface TransformObjectOptions<TSRC> {
-                       /**
-                        * If `strict` is `true` then unused properties in the source object cause
-                        * an error, otherwise they are ignored.
-                        */
-                       strict: true;
-                       /**
-                        * An optional list of source properties to be ignored when strict mode
-                        * is enabled.
-                        */
-                       ignore?: (keyof TSRC)[];
-                       /**
-                        * An optional description of this transform to be used for error messages.
-                        */
-                       description?: string;
-                   }
-
+                   onFailure(__: FailureContinuation<T>): Result<T>;
                    /**
-                    * An in-place {@link Validation.Validator | Validator} that can be instantiated using a type guard
-                    * function.
-                    * @public
+                    * {@inheritdoc IResult.withFailureDetail}
                     */
-                   declare class TypeGuardValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
-                       /**
-                        * {@link Validation.ValidatorOptions | Options} which apply to this
-                        * validator.
-                        */
-                       readonly options: ValidatorOptions<TC>;
-                       readonly description: string;
-                       protected readonly _guard: TypeGuardWithContext<T, TC>;
-                       /**
-                        * Constructs a new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator}.
-                        * @param params - Optional {@link Validation.Classes.TypeGuardValidatorConstructorParams | init params} for the
-                        * new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator}.
-                        */
-                       constructor(params: TypeGuardValidatorConstructorParams<T, TC>);
-                       /**
-                        * Static method which validates that a supplied `unknown` value matches the supplied
-                        * type guard, returning a `Failure<T>` containing more information about a failure.
-                        * @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 _validate(from: unknown, context?: TC): boolean | Failure<T>;
-                   }
-
+                   withFailureDetail<TD>(__detail: TD): DetailedResult<T, TD>;
                    /**
-                    * Parameters used to construct a {@link Validation.Classes.TypeGuardValidator}.
-                    * @public
+                    * {@inheritdoc IResult.withDetail}
                     */
-                   declare interface TypeGuardValidatorConstructorParams<T, TC = unknown> extends ValidatorBaseConstructorParams<T, TC> {
-                       guard: TypeGuardWithContext<T, TC>;
-                       description: string;
-                   }
+                   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 Conversion.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 Conversion.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 to create a strongly-typed {@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.
+                *
+                * @param destinationFields - An object with key names that correspond to the target object and an
+                * appropriate {@link Converters.FieldTransformers | FieldTransformers} which specifies the name
+                * of the corresponding property in the source object, the converter used to convert the source
+                * property and any configuration to guide the conversion.
+                * @param options - Options which affect the transformation.
+                *
+                * @returns A {@link Converter} with the specified conversion behavior.
+                * @public
+                */
+               declare function transformObject<TSRC, TDEST, TC = unknown>(destinationFields: FieldTransformers<TSRC, TDEST, TC>, options?: TransformObjectOptions<TSRC>): Converter<TDEST, TC>;
+
+               /**
+                * Options for a {@link Converters.transformObject} call.
+                * @public
+                */
+               declare interface TransformObjectOptions<TSRC> {
                    /**
-                    * A type guard function which validates a specific type, with an optional context
-                    * that can be used to shape the validation.
-                    * @public
+                    * If `strict` is `true` then unused properties in the source object cause
+                    * an error, otherwise they are ignored.
                     */
-                   declare type TypeGuardWithContext<T, TC = unknown> = (from: unknown, context?: TC) => from is T;
-
+                   strict: true;
                    /**
-                    * Helper function to create a {@link Converter} from any {@link Validation.Validator}
-                    * @param validator - the validator to be wrapped
-                    * @returns A {@link Converter} which uses the supplied validator.
-                    * @public
+                    * An optional list of source properties to be ignored when strict mode
+                    * is enabled.
                     */
-                   declare function validated<T, TC = unknown>(validator: Validator<T, TC>): Converter<T, TC>;
+                   ignore?: (keyof TSRC)[];
+                   /**
+                    * An optional description of this transform to be used for error messages.
+                    */
+                   description?: string;
+               }
 
+               /**
+                * An in-place {@link Validation.Validator | Validator} that can be instantiated using a type guard
+                * function.
+                * @public
+                */
+               declare class TypeGuardValidator<T, TC = unknown> extends ValidatorBase<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
+                    * {@link Validation.ValidatorOptions | Options} which apply to this
+                    * validator.
                     */
-                   declare function validateWith<T, TC = undefined>(validator: (from: unknown) => from is T, description?: string): Converter<T, TC>;
-
-                   declare namespace Validation {
-                       export {
-                           Base,
-                           Classes,
-                           Validators,
-                           TypeGuardWithContext,
-                           FunctionConstraintTrait,
-                           ConstraintTrait,
-                           ValidatorTraitValues,
-                           defaultValidatorTraits,
-                           ValidatorTraits,
-                           ValidatorOptions,
-                           Constraint,
-                           Validator
-                       }
+                   readonly options: ValidatorOptions<TC>;
+                   readonly description: string;
+                   protected readonly _guard: TypeGuardWithContext<T, TC>;
+                   /**
+                    * Constructs a new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator}.
+                    * @param params - Optional {@link Validation.Classes.TypeGuardValidatorConstructorParams | init params} for the
+                    * new {@link Validation.Classes.TypeGuardValidator | TypeGuardValidator}.
+                    */
+                   constructor(params: TypeGuardValidatorConstructorParams<T, TC>);
+                   /**
+                    * Static method which validates that a supplied `unknown` value matches the supplied
+                    * type guard, returning a `Failure<T>` containing more information about a failure.
+                    * @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 _validate(from: unknown, context?: TC): boolean | Failure<T>;
+               }
+
+               /**
+                * Parameters used to construct a {@link Validation.Classes.TypeGuardValidator}.
+                * @public
+                */
+               declare interface TypeGuardValidatorConstructorParams<T, TC = unknown> extends ValidatorBaseConstructorParams<T, TC> {
+                   guard: TypeGuardWithContext<T, TC>;
+                   description: string;
+               }
+
+               /**
+                * A type guard function which validates a specific type, with an optional context
+                * that can be used to shape the validation.
+                * @public
+                */
+               declare type TypeGuardWithContext<T, TC = unknown> = (from: unknown, context?: TC) => from is T;
+
+               /**
+                * Helper function to create a {@link Converter} from any {@link Validation.Validator}
+                * @param validator - the validator to be wrapped
+                * @returns A {@link Converter} which uses the supplied validator.
+                * @public
+                */
+               declare function validated<T, TC = unknown>(validator: Validator<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,
+                       TypeGuardWithContext,
+                       FunctionConstraintTrait,
+                       ConstraintTrait,
+                       ValidatorTraitValues,
+                       defaultValidatorTraits,
+                       ValidatorTraits,
+                       ValidatorOptions,
+                       Constraint,
+                       Validator
                    }
-                   export { Validation }
+               }
+               export { Validation }
 
+               /**
+                * In-place validation that a supplied unknown matches some
+                * required characteristics (type, values, etc).
+                * @public
+                */
+               export declare interface Validator<T, TC = undefined> {
                    /**
-                    * In-place validation that a supplied unknown matches some
-                    * required characteristics (type, values, etc).
-                    * @public
+                    * {@link Validation.ValidatorTraits | Traits} describing this validation.
                     */
-                   export 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 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.
                         */
-                       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>;
-                        }
+                    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> {
                         /**
-                         * Abstract base helper class for specific validator implementations
+                         * Inner constructor
+                         * @param params - Initialization params.
                          * @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>;
-                        }
-
+                        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
                          */
-                        declare type ValidatorBaseConstructorParams<T, TC> = Omit<GenericValidatorConstructorParams<T, TC>, 'validator'>;
+                        protected abstract _validate(from: unknown, context?: TC): boolean | Failure<T>;
+                    }
 
-                        /**
-                         * 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>;
+                    /**
+                     * @internal
+                     */
+                    declare type ValidatorBaseConstructorParams<T, TC> = Omit<GenericValidatorConstructorParams<T, TC>, 'validator'>;
 
-                        /**
-                         * Options that apply to any {@link Validation.Validator | Validator}.
-                         * @public
-                         */
-                        declare interface ValidatorOptions<TC> {
-                            defaultContext?: TC;
-                        }
+                    /**
+                     * 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>;
 
-                        declare namespace Validators {
-                            export {
-                                object_2 as object,
-                                arrayOf_2 as arrayOf,
-                                enumeratedValue_2 as enumeratedValue,
-                                literal_2 as literal,
-                                isA_2 as isA,
-                                string_2 as string,
-                                number_2 as number,
-                                boolean_2 as boolean
-                            }
+                    /**
+                     * Options that apply to any {@link Validation.Validator | Validator}.
+                     * @public
+                     */
+                    declare interface ValidatorOptions<TC> {
+                        defaultContext?: TC;
+                    }
+
+                    declare namespace Validators {
+                        export {
+                            object_2 as object,
+                            arrayOf_2 as arrayOf,
+                            enumeratedValue_2 as enumeratedValue,
+                            literal_2 as literal,
+                            isA_2 as isA,
+                            string_2 as string,
+                            number_2 as number,
+                            boolean_2 as boolean
                         }
-                        export { Validators }
+                    }
+                    export { Validators }
 
+                    /**
+                     * Generic implementation of {@link Validation.ValidatorTraitValues | ValidatorTraitValues}.
+                     * @public
+                     */
+                    declare class ValidatorTraits implements ValidatorTraitValues {
                         /**
-                         * Generic implementation of {@link Validation.ValidatorTraitValues | ValidatorTraitValues}.
-                         * @public
+                         * {@inheritdoc Validation.ValidatorTraitValues.isOptional}
                          */
-                        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);
-                        }
-
+                        readonly isOptional: boolean;
                         /**
-                         * Interface describing the supported validator traits.
-                         * @public
+                         * {@inheritdoc Validation.ValidatorTraitValues.brand}
                          */
-                        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[];
-                        }
+                        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 {
                         /**
-                         * Deprecated alias for @see literal
-                         * @param value - The value to be compared.
-                         * @deprecated Use {@link Converters.literal} instead.
-                         * @internal
+                         * Indicates whether the validator accepts `undefined` as
+                         * a valid value.
                          */
-                        declare const value: typeof literal;
+                        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 { }
+                    export { }