@fgv/ts-utils 3.0.1-alpha.3 → 3.0.1-alpha.5

package/dist/ts-utils.d.ts

@@ -1,12 +1,15 @@
 /**
  * Determines if an iterable collection of {@link Result | Result<T>} were all successful.
  * @param results - The collection of {@link Result | Result<T>} to be tested.
- * @returns Returns {@link Success} with `true` if all {@link Result | results} are successful.
- * If any are unsuccessful, returns {@link Failure} with a concatenated summary the error
+ * @param successValue - The value to be returned if results are successful.
+ * @param aggregatedErrors  - Optional string array to which any returned error messages will be
+ * appended.  Each error is appended as an individual string.
+ * @returns Returns {@link Success} with `successValue` if all {@link Result | results} are successful.
+ * If any are unsuccessful, returns {@link Failure} with a concatenated summary of the error
  * messages from all failed elements.
  * @public
  */
-export declare function allSucceed<T>(results: Iterable<Result<unknown>>, successValue: T): Result<T>;
+export declare function allSucceed<T>(results: Iterable<Result<unknown>>, successValue: T, aggregatedErrors?: IMessageAggregator): Result<T>;
 
 /**
  * A helper function to create a {@link Converter | Converter} which converts `unknown` to an array of `<T>`.
@@ -823,6 +826,10 @@ export declare class Failure<T> implements IResult<T> {
      * {@inheritdoc IResult.withDetail}
      */
     withDetail<TD>(detail: TD, __successDetail?: TD): DetailedResult<T, TD>;
+    /**
+     * {@inheritdoc IResult.aggregateError}
+     */
+    aggregateError(errors: IMessageAggregator): this;
     /**
      * Get a 'friendly' string representation of this object.
      * @remarks
@@ -1143,6 +1150,41 @@ declare class HashingNormalizer extends Normalizer {
     protected _normalizeLiteralToString(from: string | number | bigint | boolean | symbol | undefined | Date | RegExp | null): Result<string>;
 }
 
+/**
+ * Simple error aggregator to simplify collecting all errors in
+ * a flow.
+ * @public
+ */
+export declare interface IMessageAggregator {
+    /**
+     * Indicates whether any messages have been aggregated.
+     */
+    readonly hasMessages: boolean;
+    /**
+     * The aggregated messages.
+     */
+    readonly messages: ReadonlyArray<string>;
+    /**
+     * Adds a message to the aggregator, if defined.
+     * @param message - The message to add - pass `undefined`
+     * or the empty string to continue without adding a message.
+     */
+    addMessage(message: string | undefined): this;
+    /**
+     * Adds multiple messages to the aggregator.
+     * @param messages - the messages to add.
+     */
+    addMessages(messages: string[] | undefined): this;
+    /**
+     * Returns all messages as a single string joined
+     * using the optionally-supplied `separator`, or
+     * newline if no separator is specified.
+     * @param separator - The optional separator used
+     * to join strings.
+     */
+    toString(separator?: string): string;
+}
+
 /**
  * Infers the type that will be returned by an instantiated converter.  Works
  * for complex as well as simple types.
@@ -1291,6 +1333,13 @@ export declare interface IResult<T> {
      * appropriate added detail.
      */
     withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;
+    /**
+     * Propagates interior result, appending any error message to the
+     * supplied errors array.
+     * @param errors - {@link IMessageAggregator | Error aggregator} in which
+     * errors will be aggregated.
+     */
+    aggregateError(errors: IMessageAggregator): this;
 }
 
 /**
@@ -1436,24 +1485,28 @@ declare type LogLevel = 'detail' | 'info' | 'warning' | 'error' | 'silent';
  * 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.
+ * @param aggregatedErrors  - Optional string array to which any non-ignorable error messages will be
+ * appended.  Each error is appended as an individual string.
  * @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[]>;
+ export declare function mapDetailedResults<T, TD>(results: Iterable<DetailedResult<T, TD>>, ignore: TD[], aggregatedErrors?: IMessageAggregator): 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.
+  * @param aggregatedErrors  - Optional string array to which any returned error messages will be
+  * appended.  Each error is appended as an individual string.
   * @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[];
+ export declare function mapFailures<T>(results: Iterable<Result<T>>, aggregatedErrors?: IMessageAggregator): string[];
 
  /**
   * A helper function to create a {@link Converter | Converter} which converts the `string`-keyed properties
@@ -1519,23 +1572,27 @@ declare type LogLevel = 'detail' | 'info' | 'warning' | 'error' | 'silent';
  /**
   * Aggregates successful result values from a collection of {@link Result | Result<T>}.
   * @param results - The collection of {@link Result | Result<T>} to be mapped.
+  * @param aggregatedErrors  - Optional string array to which any error messages will be
+  * appended.  Each error is appended as an individual string.
   * @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[]>;
+ export declare function mapResults<T>(results: Iterable<Result<T>>, aggregatedErrors?: IMessageAggregator): 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.
+  * @param aggregatedErrors  - Optional string array to which any returned error messages will be
+  * appended.  Each error is appended as an individual string.
   * @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[]>;
+  export declare function mapSuccess<T>(results: Iterable<Result<T>>, aggregatedErrors?: IMessageAggregator): Result<T[]>;
 
   /**
    * Applies a factory method to convert a `ReadonlyMap<TK, TS>` into a `Record<TK, TD>`.
@@ -1548,1293 +1605,1356 @@ declare type LogLevel = 'detail' | 'info' | 'warning' | 'error' | 'silent';
    export declare function mapToRecord<TS, TD, TK extends string = string>(src: ReadonlyMap<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<TK, TD>>;
 
    /**
+    * A simple error aggregator to simplify collecting and reporting all errors in
+    * a flow.
     * @public
     */
-   declare class NoOpLogger extends LoggerBase {
-       protected _innerLog(message: string): Success<string | undefined>;
-   }
-
-   /**
-    * Normalizes an arbitrary JSON object
-    * @public
-    */
-   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.
-        */
-       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.
-        */
-       normalizeLiteral<T>(from: T): Result<T>;
-   }
-
-   /**
-    * A {@link Converter | 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> {
-       /**
-        * Constructs a new {@link Validation.Classes.NumberValidator | NumberValidator}.
-        * @param params - Optional {@link Validation.Classes.NumberValidatorConstructorParams | init params} for the
-        * new {@link Validation.Classes.NumberValidator | NumberValidator}.
-        */
-       constructor(params?: NumberValidatorConstructorParams<T, TC>);
-       /**
-        * Static method which validates that a supplied `unknown` value is a `number`.
-        * @param from - The `unknown` value to be tested.
-        * @returns Returns `true` if `from` is a `number`, or {@link Failure} with an error
-        * message if not.
-        */
-       static validateNumber<T extends number>(from: unknown): boolean | Failure<T>;
-   }
-
-   /**
-    * Parameters used to construct a {@link Validation.Classes.NumberValidator | NumberValidator}.
-    * @public
-    */
-   declare type NumberValidatorConstructorParams<T extends number = number, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
-
-   /**
-    * Helper function to create a {@link 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 | 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 | 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 | 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 | 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
-    */
-   export declare class ObjectConverter<T, TC = unknown> extends BaseConverter<T, TC> {
+   export declare class MessageAggregator implements IMessageAggregator {
+       private readonly _messages;
        /**
-        * Fields converted by this {@link Conversion.ObjectConverter | ObjectConverter}.
+        * Constructs a new {@link MessageAggregator | ErrorAggregator} with an
+        * optionally specified initial set of error messages.
+        * @param errors - optional array of errors to be included
+        * in the aggregation.
         */
-       readonly fields: FieldConverters<T>;
+       constructor(errors?: string[]);
        /**
-        * Options used to initialize this {@link Conversion.ObjectConverter | ObjectConverter}.
+        * {@inheritdoc IMessageAggregator.hasMessages}
         */
-       readonly options: ObjectConverterOptions<T>;
+       get hasMessages(): boolean;
        /**
-        * 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}
+        * {@inheritdoc IMessageAggregator.messages}
         */
-       constructor(fields: FieldConverters<T, TC>, options?: ObjectConverterOptions<T>);
+       get messages(): string[];
        /**
-        * 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}
+        * {@inheritdoc IMessageAggregator.addMessage}
         */
-       constructor(fields: FieldConverters<T, TC>, optional?: (keyof T)[]);
+       addMessage(message: string | undefined): this;
        /**
-        * 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}
+        * {@inheritdoc IMessageAggregator.addMessages}
         */
-       partial(options: ObjectConverterOptions<T>): ObjectConverter<Partial<T>, TC>;
+       addMessages(messages: string[] | undefined): this;
        /**
-        * 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}
+        * {@inheritdoc IMessageAggregator.toString}
         */
-       partial(optional?: (keyof T)[]): ObjectConverter<Partial<T>, TC>;
+       toString(separator?: string): string;
        /**
-        * 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>;
-   }
+        * If any error messages have been aggregated, returns
+        * {@link Failure | Failure<T>} with the aggregated
+        * messages concatenated using the optionally-supplied
+        * separator, or newline.   If the supplied {@link Result | Result<T>}
+        * contains an error message that has not already been aggregated,
+        * it will be included in the aggregated messages.
+        *
+        * If no error messages have been aggregated, returns
+        * the supplied {@link Result | Result<T>}.
+        * @param result - The {@link Result | Result<T>} to be returned
+        * if no messages have been aggregated.
+        * @param separator - Optional string separator used to construct
+        * the error message.
+        * @returns {@link Failure | Failure<T>} with an aggregated message
+            * if any error messages were collected, the supplied
+            * {@link Result | Result<T>} otherwise.
+            */
+        returnOrReport<T>(result: Result<T>, separator?: string): Result<T>;
+       }
 
-   /**
-    * 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.
+        * @public
         */
-       description?: string;
-   }
+       declare class NoOpLogger extends LoggerBase {
+           protected _innerLog(message: string): Success<string | undefined>;
+       }
 
-   /**
-    * In-place {@link Validation.Validator | Validator} for an object of type `<T>`.
-    * @remarks
-    * By default, succeeds if all of the required fields exist and are validate, and fails if
-    * any required fields do not exist or are invalid.  See {@link Validation.Classes.ObjectValidatorOptions}
-    * for other validation options.
-    * @public
-    */
-   declare class ObjectValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
-       /**
-        * A {@link Validation.Classes.FieldValidators | FieldValidators} object specifying a
-        * {@link Validation.Validator | Validator} for each of the expected properties
-        */
-       readonly fields: FieldValidators<T>;
        /**
-        * {@link Validation.Classes.ObjectValidatorOptions | Options} which apply to this
-        * validator.
-        */
-       readonly options: ObjectValidatorOptions<T, TC>;
-       /**
-        * @internal
-        */
-       protected readonly _innerValidators: FieldValidators<T>;
-       /**
-        * @internal
-        */
-       protected readonly _allowedFields?: Set<keyof T>;
-       /**
-        * Constructs a new {@link Validation.Classes.ObjectValidator | ObjectValidator<T>}.
-        * @param fields - A {@link Validation.Classes.FieldValidators | FieldValidators<T>} containing
-        * a {@link Validation.Validator | Validator} for each field.
-        * @param options - An optional {@link Validation.Classes.ObjectValidatorOptions} to configure
-        * validation.
+        * Normalizes an arbitrary JSON object
+        * @public
         */
-       constructor(params: ObjectValidatorConstructorParams<T, TC>);
+       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.
+            */
+           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.
+            */
+           normalizeLiteral<T>(from: T): Result<T>;
+       }
+
        /**
-        * 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
+        * A {@link Converter | Converter} which converts `unknown` to a `number`.
+        * @remarks
+        * Numbers and strings with a numeric format succeed. Anything else fails.
+        * @public
         */
-       protected static _resolveValidators<T, TC>(fields: FieldValidators<T, TC>, options?: ObjectValidatorOptions<T, TC>): FieldValidators<T, TC>;
+       declare const number: Converter<number, undefined>;
+
        /**
-        * 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.
+        * A {@link Validation.Classes.NumberValidator | NumberValidator} which validates a number in place.
+        * @public
         */
-       partial(options?: ObjectValidatorOptions<T, TC>): ObjectValidator<Partial<T>, TC>;
+       declare const number_2: Validator<number>;
+
        /**
-        * 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.
+        * {@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
         */
-       addPartial(addOptionalFields: (keyof T)[]): ObjectValidator<Partial<T>, TC>;
+       declare const numberArray: Converter<number[]>;
+
        /**
-        * {@inheritdoc Validation.ValidatorBase._validate}
-        * @internal
+        * An in-place {@link Validation.Validator | Validator} for `number` values.
+        * @public
         */
-       protected _validate(from: unknown, context?: TC): boolean | Failure<T>;
-   }
+       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>;
+       }
 
-   /**
-    * 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.
+        * Parameters used to construct a {@link Validation.Classes.NumberValidator | NumberValidator}.
+        * @public
         */
-       fields: FieldValidators<T>;
+       declare type NumberValidatorConstructorParams<T extends number = number, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
+
        /**
-        * Optional additional {@link Validation.Classes.ObjectValidatorOptions | ValidatorOptions} to
-        * configure validation.
+        * 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 | 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 | 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
         */
-       options?: ObjectValidatorOptions<T, TC>;
-   }
+       declare function object<T>(properties: FieldConverters<T>, options?: ObjectConverterOptions<T>): ObjectConverter<T>;
 
-   /**
-    * 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.
+        * 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 | 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 | 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.
         */
-       optionalFields?: (keyof T)[];
+       declare function object<T>(properties: FieldConverters<T>, optional: (keyof T)[]): ObjectConverter<T>;
+
        /**
-        * If true, unrecognized fields yield an error.  If false or undefined (default),
-        * unrecognized fields are ignored.
+        * 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
         */
-       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 | 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} or {@link Validator | validators}
-    * to be considered.
-    * @param onError - Specifies treatment of unconvertible elements.
-    * @returns A new {@link Converter | 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> | Validator<T, TC>>, onError?: OnError): Converter<T, TC>;
-
-   /**
-    * Helper function to create a {@link Validation.Validator | Validator} which validates one
-    * of several possible validated values.
-    * @param validators - the {@link Validation.Validator | validators} to be considered.
-    * @param params - Optional {@link Validation.Classes.OneOfValidatorConstructorParams | params} used to construct the validator.
-    * @returns A new {@link Validator | Validator} which validates values that match any of
-    * the supplied validators.
-    * @public
-    */
-   declare function oneOf_2<T, TC = unknown>(validators: Array<Validator<T, TC>>, params?: Omit<OneOfValidatorConstructorParams<T, TC>, 'validators'>): OneOfValidator<T, TC>;
+       declare function object_2<T, TC = unknown>(fields: FieldValidators<T, TC>, params?: Omit<ObjectValidatorConstructorParams<T, TC>, 'fields'>): ObjectValidator<T, TC>;
 
-   /**
-    * An in-place {@link Validator | Validator} which validates that a supplied
-    * value matches one of several other validators.
-    * @public
-    */
-   declare class OneOfValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
        /**
-        * {@link Validation.ValidatorOptions | Options} which apply to this
-        * validator.
+        * 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
         */
-       readonly options: ValidatorOptions<TC>;
-       protected readonly _validators: Validator<T, TC>[];
+       export 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>;
+       }
+
        /**
-        * Constructs a new {@link Validation.Classes.OneOfValidator | OneOfValidator}.
-        * @param params - Optional {@link Validation.Classes.OneOfValidatorConstructorParams | init params} for the
-        * new {@link Validation.Classes.OneOfValidator | OneOfValidator}.
+        * Options for an {@link Conversion.ObjectConverter | ObjectConverter}.
+        * @public
         */
-       constructor(params: OneOfValidatorConstructorParams<T, TC>);
+       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;
+       }
+
        /**
-        * Static method which validates that a supplied `unknown` value matches at least one
-        * of the configured validators.
-        * @param from - The `unknown` value to be tested.
-        * @param context - Optional validation context will be propagated to element validator.
-        * @returns Returns `true` if `from` is an `array` of valid elements, or
-        * {@link Failure} with an error message if not.
+        * 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
         */
-       protected _validate<T>(from: unknown, context?: TC): boolean | Failure<T>;
-   }
-
-   /**
-    * Parameters used to construct a {@link Validation.Classes.OneOfValidator | OneOfValidator}.
-    * @public
-    */
-   declare interface OneOfValidatorConstructorParams<T, TC = unknown> extends ValidatorBaseConstructorParams<T, TC> {
-       validators: Validator<T, TC>[];
-   }
-
-   /**
-    * Action to take on conversion failures.
-    * @public
-    */
-   declare type OnError = 'failOnError' | 'ignoreErrors';
-
-   /**
-    * A {@link Converter | 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 | Success}
-    * with value `undefined`.
-    * @public
-    */
-   declare const optionalBoolean: Converter<boolean | undefined>;
-
-   /**
-    * A helper function to create a {@link Converter | Converter} which extracts and converts an optional element from an array.
-    * @remarks
-    * The resulting {@link Converter | Converter} returns {@link Success | Success} with the converted value if the element exists
-    * in the supplied array and can be converted. Returns {@link Success | Success} with value `undefined` if the parameter
-    * is an array but the index is out of range. Returns {@link Failure | 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 | Converter} or {@link Validator | Validator} used for 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> | Validator<T, TC>): Converter<T | undefined, TC>;
-
-   /**
-    * A helper function to create a {@link Converter | Converter} which extracts and convert a property specified
-    * by name from an object.
-    * @remarks
-    * The resulting {@link Converter | Converter} returns {@link Success | Success} with the converted value of
-    * the corresponding object property if the field exists and can be converted. Returns {@link Success | Success}
-    * with `undefined` if the supplied parameter is an object but the named field is not present.
-    * Returns {@link Failure | Failure} with an error message otherwise.
-    * @param name - The name of the field to be extracted.
-    * @param converter - {@link Converter | Converter} or {@link Validator | Validator} to use for the extracted field.
-    * @public
-    */
-   declare function optionalField<T, TC = undefined>(name: string, converter: Converter<T, TC> | Validator<T, TC>): Converter<T | undefined, TC>;
+       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>;
+       }
 
-   /**
-    * 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.
+       /**
+        * Options for the {@link Validation.Classes.ObjectValidator | ObjectValidator} constructor.
         * @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>>;
-
-    /**
-     * 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 | Converter} which converts an optional `number` value.
-      * @remarks
-      * Values of type `number` or numeric strings are converted and returned.
-      * Anything else returns {@link Success | 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>>;
+       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>;
+       }
 
        /**
-        * A {@link Converter | Converter} which converts an optional `string` value. Values of type
-        * `string` are returned.  Anything else returns {@link Success | Success} with value `undefined`.
+        * Options for an {@link Validation.Classes.ObjectValidator | ObjectValidator}.
         * @public
         */
-       declare const optionalString: Converter<string | undefined, unknown>;
+       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 pick function, which picks a set of properties from a supplied
-        * object.  Ignores picked properties that do not exist regardless of type signature.
+        * 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 include - The keys of the properties to be picked from `from`.
-        * @returns A new object containing the requested properties from `from`, where present.
+        * @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 pick<T extends object, K extends keyof T>(from: T, include: K[]): Pick<T, K>;
+       export declare function omit<T extends object, K extends keyof T>(from: T, exclude: K[]): Omit<T, K>;
 
        /**
-        * 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}
+        * A helper function to create a {@link Converter | 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} or {@link Validator | validators}
+        * to be considered.
+        * @param onError - Specifies treatment of unconvertible elements.
+        * @returns A new {@link Converter | Converter} which yields a value from the union of the types returned
+        * by the wrapped converters.
         * @public
         */
-       export declare function populateObject<T>(initializers: FieldInitializers<T>, options?: PopulateObjectOptions<T>): Result<T>;
+       declare function oneOf<T, TC = unknown>(converters: Array<Converter<T, TC> | Validator<T, TC>>, onError?: OnError): Converter<T, TC>;
 
        /**
-        * 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.
+        * Helper function to create a {@link Validation.Validator | Validator} which validates one
+        * of several possible validated values.
+        * @param validators - the {@link Validation.Validator | validators} to be considered.
+        * @param params - Optional {@link Validation.Classes.OneOfValidatorConstructorParams | params} used to construct the validator.
+        * @returns A new {@link Validator | Validator} which validates values that match any of
+        * the supplied validators.
         * @public
-        * {@label WITH_ORDER}
-        * @deprecated Pass {@link PopulateObjectOptions} instead.
         */
-       export declare function populateObject<T>(initializers: FieldInitializers<T>, order: (keyof T)[]): Result<T>;
+       declare function oneOf_2<T, TC = unknown>(validators: Array<Validator<T, TC>>, params?: Omit<OneOfValidatorConstructorParams<T, TC>, 'validators'>): OneOfValidator<T, TC>;
 
        /**
-        * Options for the {@link (populateObject:1)} function.
+        * An in-place {@link Validator | Validator} which validates that a supplied
+        * value matches one of several other validators.
         * @public
         */
-       export declare interface PopulateObjectOptions<T> {
+       declare class OneOfValidator<T, TC = unknown> extends ValidatorBase<T, TC> {
+           /**
+            * {@link Validation.ValidatorOptions | Options} which apply to this
+            * validator.
+            */
+           readonly options: ValidatorOptions<TC>;
+           protected readonly _validators: Validator<T, TC>[];
            /**
-            * 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.
+            * Constructs a new {@link Validation.Classes.OneOfValidator | OneOfValidator}.
+            * @param params - Optional {@link Validation.Classes.OneOfValidatorConstructorParams | init params} for the
+            * new {@link Validation.Classes.OneOfValidator | OneOfValidator}.
             */
-           order?: (keyof T)[];
+           constructor(params: OneOfValidatorConstructorParams<T, TC>);
            /**
-            * 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.
+            * Static method which validates that a supplied `unknown` value matches at least one
+            * of the configured validators.
+            * @param from - The `unknown` value to be tested.
+            * @param context - Optional validation context will be propagated to element validator.
+            * @returns Returns `true` if `from` is an `array` of valid elements, or
+            * {@link Failure} with an error message if not.
             */
-           suppressUndefined?: boolean | (keyof T)[];
+           protected _validate<T>(from: unknown, context?: TC): boolean | Failure<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.
+        * Parameters used to construct a {@link Validation.Classes.OneOfValidator | OneOfValidator}.
         * @public
         */
-       export declare function propagateWithDetail<T, TD>(result: Result<T>, detail: TD, successDetail?: TD): DetailedResult<T, TD>;
+       declare interface OneOfValidatorConstructorParams<T, TC = unknown> extends ValidatorBaseConstructorParams<T, TC> {
+           validators: Validator<T, TC>[];
+       }
+
+       /**
+        * Action to take on conversion failures.
+        * @public
+        */
+       declare type OnError = 'failOnError' | 'ignoreErrors';
 
        /**
-        * A helper function to create a {@link Converter | Converter} which converts the `string`-keyed
-        * properties using a supplied {@link Converter | Converter<T>} or {@link Validator | Validator<T>} to
-        * produce a `Record<string, T>`.
+        * A {@link Converter | Converter} to convert an optional `boolean` value.
         * @remarks
-        * The resulting converter fails conversion if any element cannot be converted.
-        * @param converter - {@link Converter | Converter} or {@link Validator | Validator} used for each
-        * item in the source object.
-        * @returns A {@link Converter | Converter} which returns `Record<string, T>`.
-        * {@label WITH_DEFAULT}
+        * Values of type `boolean` or strings that match (case-insensitive) `'true'`
+        * or `'false'` are converted and returned.  Anything else returns {@link Success | Success}
+        * with value `undefined`.
         * @public
         */
-       declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>): Converter<Record<TK, T>, TC>;
+       declare const optionalBoolean: Converter<boolean | undefined>;
 
        /**
-        * A helper function to create a {@link Converter | Converter} which converts the `string`-keyed properties
-        * using a supplied {@link Converter | Converter<T>} or {@link Validator | Validator<T>} to produce a
-        * `Record<string, T>` and optionally specified handling of elements that cannot be converted.
+        * A helper function to create a {@link Converter | Converter} which extracts and converts an optional element from an array.
         * @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 | Converter} or {@link Validator | Validator} for each item in
-        * the source object.
-        * @returns A {@link Converter | Converter} which returns `Record<string, T>`.
-        * {@label WITH_ON_ERROR}
+        * The resulting {@link Converter | Converter} returns {@link Success | Success} with the converted value if the element exists
+        * in the supplied array and can be converted. Returns {@link Success | Success} with value `undefined` if the parameter
+        * is an array but the index is out of range. Returns {@link Failure | 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 | Converter} or {@link Validator | Validator} used for the extracted element.
+        * @returns A {@link Converter | Converter<T>} which extracts the specified element from an array.
         * @public
         */
-       declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>, onError: 'fail' | 'ignore'): Converter<Record<TK, T>, TC>;
+       declare function optionalElement<T, TC = undefined>(index: number, converter: Converter<T, TC> | Validator<T, TC>): Converter<T | undefined, TC>;
 
        /**
-        * A helper function to create a {@link Converter | Converter} or which converts the `string`-keyed properties
-        * using a supplied {@link Converter | Converter<T>} or {@link Validator | Validator<T>} to produce a
-        * `Record<TK, T>`.
+        * A helper function to create a {@link Converter | Converter} which extracts and convert a property specified
+        * by name from an object.
         * @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 | Converter} or {@link Validator | Validator} used for 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 | Converter} which returns `Record<TK, T>`.
-        * {@label WITH_OPTIONS}
+        * The resulting {@link Converter | Converter} returns {@link Success | Success} with the converted value of
+        * the corresponding object property if the field exists and can be converted. Returns {@link Success | Success}
+        * with `undefined` if the supplied parameter is an object but the named field is not present.
+        * Returns {@link Failure | Failure} with an error message otherwise.
+        * @param name - The name of the field to be extracted.
+        * @param converter - {@link Converter | Converter} or {@link Validator | Validator} to use for the extracted field.
         * @public
         */
-       declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>, options: KeyedConverterOptions<TK, TC>): Converter<Record<TK, T>, TC>;
+       declare function optionalField<T, TC = undefined>(name: string, converter: Converter<T, TC> | Validator<T, TC>): Converter<T | undefined, TC>;
 
        /**
-        * Applies a factory method to convert a `Record<TK, TS>` into a `Map<TK, TD>`.
-        * @param src - The `Record` to be converted.
+        * 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 map on success, or {@link Failure} with a
-            * message if an error occurs.
+        * @returns {@link Success} with the resulting record (empty if `src` is `undefined`) if conversion succeeds.
+            * Returns {@link Failure} with a message if an error occurs.
             * @public
             */
-        export declare function recordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>>;
+        export declare function optionalMapToPossiblyEmptyRecord<TS, TD, TK extends string = string>(src: ReadonlyMap<TK, TS> | undefined, factory: KeyedThingFactory<TS, TD, TK>): Result<Record<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>;
+         * 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>;
 
-        /**
-         * 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;
+         /**
+          * A {@link Converter | Converter} which converts an optional `number` value.
+          * @remarks
+          * Values of type `number` or numeric strings are converted and returned.
+          * Anything else returns {@link Success | 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>>;
 
-        /**
-         * Type inference to determine the result type of an {@link Result}.
-         * @beta
-         */
-        export declare type ResultValueType<T> = T extends Result<infer TV> ? TV : never;
+           /**
+            * A {@link Converter | Converter} which converts an optional `string` value. Values of type
+            * `string` are returned.  Anything else returns {@link Success | Success} with value `undefined`.
+            * @public
+            */
+           declare const optionalString: Converter<string | undefined, unknown>;
 
-        /**
-         * 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>;
+           /**
+            * 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 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>;
+           /**
+            * 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.
+            * @param aggregatedErrors  - Optional string array to which any returned error messages will be
+            * appended.  Each error is appended as an individual string.
+            * {@label WITH_OPTIONS}
+            * @public
+            */
+           export declare function populateObject<T>(initializers: FieldInitializers<T>, options?: PopulateObjectOptions<T>, aggregatedErrors?: IMessageAggregator): Result<T>;
 
-        /**
-         * Options for the {@link Converters.(strictObject:1)} helper function.
-         * @public
-         */
-        declare type StrictObjectConverterOptions<T> = Omit<ObjectConverterOptions<T>, 'strict'>;
+           /**
+            * 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.
+            * @param aggregatedErrors  - Optional string array to which any returned error messages will be
+            * appended.  Each error is appended as an individual string.
+            * @public
+            * {@label WITH_ORDER}
+            * @deprecated Pass {@link PopulateObjectOptions} instead.
+            */
+           export declare function populateObject<T>(initializers: FieldInitializers<T>, order: (keyof T)[] | undefined, aggregatedErrors?: IMessageAggregator): Result<T>;
 
-        /**
-         * A converter to convert unknown to string. Values of type
-         * string succeed.  Anything else fails.
-         * @public
-         */
-        declare const string: StringConverter;
+           /**
+            * 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)[];
+           }
 
-        /**
-         * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
-         * @public
-         */
-        declare const string_2: Validator<string>;
+           /**
+            * 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>;
 
-        /**
-         * {@link Converter | Converter} to convert an `unknown` to an array of `string`.
-         * @remarks
-         * Returns {@link Success | Success} with the the supplied value if it as an array
-         * of strings, returns {@link Failure | Failure} with an error message otherwise.
-         * @public
-         */
-        declare const stringArray: Converter<string[]>;
+           /**
+            * A helper function to create a {@link Converter | Converter} which converts the `string`-keyed
+            * properties using a supplied {@link Converter | Converter<T>} or {@link Validator | Validator<T>} to
+            * produce a `Record<string, T>`.
+            * @remarks
+            * The resulting converter fails conversion if any element cannot be converted.
+            * @param converter - {@link Converter | Converter} or {@link Validator | Validator} used for each
+            * item in the source object.
+            * @returns A {@link Converter | Converter} which returns `Record<string, T>`.
+            * {@label WITH_DEFAULT}
+            * @public
+            */
+           declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>): Converter<Record<TK, T>, TC>;
+
+           /**
+            * A helper function to create a {@link Converter | Converter} which converts the `string`-keyed properties
+            * using a supplied {@link Converter | Converter<T>} or {@link Validator | Validator<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 | Converter} or {@link Validator | Validator} for each item in
+            * the source object.
+            * @returns A {@link Converter | 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> | Validator<T, TC>, onError: 'fail' | 'ignore'): Converter<Record<TK, T>, TC>;
+
+           /**
+            * A helper function to create a {@link Converter | Converter} or which converts the `string`-keyed properties
+            * using a supplied {@link Converter | Converter<T>} or {@link Validator | Validator<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 | Converter} or {@link Validator | Validator} used for 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 | Converter} which returns `Record<TK, T>`.
+            * {@label WITH_OPTIONS}
+            * @public
+            */
+           declare function recordOf<T, TC = undefined, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>, options: KeyedConverterOptions<TK, TC>): Converter<Record<TK, T>, TC>;
+
+           /**
+            * Applies a factory method to convert a `Record<TK, TS>` into a `Map<TK, TD>`.
+            * @param src - The `Record` to be converted.
+            * @param factory - The factory method used to convert elements.
+            * @returns {@link Success} with the resulting map on success, or {@link Failure} with a
+                * message if an error occurs.
+                * @public
+                */
+            export declare function recordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>>;
 
-        /**
-         * The {@link Conversion.StringConverter | StringConverter} class extends
-         * {@link Conversion.BaseConverter | BaseConverter} to provide string-specific
-         * helper methods.
-         * @public
-         */
-        export 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.
+             * 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
              */
-            constructor(defaultContext?: TC, traits?: ConverterTraits, converter?: (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>);
+            export declare type Result<T> = Success<T> | Failure<T>;
+
             /**
-             * @internal
+             * Type inference to determine the detail type `TD` of a {@link DetailedResult | DetailedResult<T, TD>}.
+             * @beta
              */
-            protected static _convert<T extends string>(from: unknown): Result<T>;
+            export declare type ResultDetailType<T> = T extends DetailedResult<unknown, infer TD> ? TD : never;
+
             /**
-             * @internal
+             * Type inference to determine the result type of an {@link Result}.
+             * @beta
              */
-            protected static _wrap<T extends string, TC>(wrapped: StringConverter<T, TC>, converter: (from: T) => Result<T>, traits?: ConverterTraits): StringConverter<T, TC>;
+            export declare type ResultValueType<T> = T extends Result<infer TV> ? TV : never;
+
             /**
-             * 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 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>;
 
-               /**
-                * 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;
-               }
+            /**
+             * 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>;
 
-               /**
-                * 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>;
-               }
+            /**
+             * Options for the {@link Converters.(strictObject:1)} helper function.
+             * @public
+             */
+            declare type StrictObjectConverterOptions<T> = Omit<ObjectConverterOptions<T>, 'strict'>;
 
-               /**
-                * Parameters used to construct a {@link Validation.Classes.StringValidator | StringValidator}.
-                * @public
-                */
-               declare type StringValidatorConstructorParams<T extends string = string, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
+            /**
+             * A converter to convert unknown to string. Values of type
+             * string succeed.  Anything else fails.
+             * @public
+             */
+            declare const string: StringConverter;
 
-               /**
-                * 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>;
+            /**
+             * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
+             * @public
+             */
+            declare const string_2: Validator<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>;
+            /**
+             * {@link Converter | Converter} to convert an `unknown` to an array of `string`.
+             * @remarks
+             * Returns {@link Success | Success} with the the supplied value if it as an array
+             * of strings, returns {@link Failure | Failure} with an error message otherwise.
+             * @public
+             */
+            declare const stringArray: Converter<string[]>;
 
-               /**
-                * Reports a successful {@link IResult | result} from some operation and the
-                * corresponding value.
-                * @public
-                */
-               export declare class Success<T> implements IResult<T> {
-                   /**
-                    * {@inheritdoc IResult.success}
-                    */
-                   readonly success: true;
-                   /**
-                    * @internal
-                    */
-                   private readonly _value;
-                   /**
-                    * Constructs a {@link Success} with the supplied value.
-                    * @param value - The value to be returned.
-                    */
-                   constructor(value: T);
-                   /**
-                    * The result value returned by the successful operation.
-                    */
-                   get value(): T;
+            /**
+             * The {@link Conversion.StringConverter | StringConverter} class extends
+             * {@link Conversion.BaseConverter | BaseConverter} to provide string-specific
+             * helper methods.
+             * @public
+             */
+            export 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>;
                    /**
-                    * {@inheritdoc IResult.isSuccess}
-                    */
-                   isSuccess(): this is Success<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.isFailure}
+                    * Options for {@link Conversion.StringConverter | StringConverter}
+                    * matching method
+                    * @public
                     */
-                   isFailure(): this is Failure<T>;
+                   declare interface StringMatchOptions {
+                       /**
+                        * An optional message to be displayed if a non-matching string
+                        * is encountered.
+                        */
+                       message?: string;
+                   }
+
                    /**
-                    * {@inheritdoc IResult.orThrow}
+                    * An in-place {@link Validation.Validator | Validator} for `string` values.
+                    * @public
                     */
-                   orThrow(__logger?: IResultLogger): T;
+                   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>;
+                   }
+
                    /**
-                    * {@inheritdoc IResult.(orDefault:1)}
+                    * Parameters used to construct a {@link Validation.Classes.StringValidator | StringValidator}.
+                    * @public
                     */
-                   orDefault(dflt: T): T;
+                   declare type StringValidatorConstructorParams<T extends string = string, TC = unknown> = GenericValidatorConstructorParams<T, TC>;
+
                    /**
-                    * {@inheritdoc IResult.(orDefault:2)}
+                    * Returns {@link Success | Success<T>} with the supplied result value.
+                    * @param value - The successful result value to be returned
+                    * @public
                     */
-                   orDefault(): T | undefined;
+                   export declare function succeed<T>(value: T): Success<T>;
+
                    /**
-                    * {@inheritdoc IResult.getValueOrThrow}
-                    * @deprecated Use {@link Success.orThrow | orThrow} instead.
+                    * 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
                     */
-                   getValueOrThrow(__logger?: IResultLogger): T;
+                   export declare function succeedWithDetail<T, TD>(value: T, detail?: TD): DetailedSuccess<T, TD>;
+
                    /**
-                    * {@inheritdoc IResult.getValueOrDefault}
-                    * @deprecated Use {@link Success.(orDefault:1) | orDefault(T)} or {@link Success.(orDefault:2) | orDefault()} instead.
+                    * Reports a successful {@link IResult | result} from some operation and the
+                    * corresponding value.
+                    * @public
                     */
-                   getValueOrDefault(dflt?: T): T | undefined;
+                   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:1)}
+                        */
+                       orDefault(dflt: T): T;
+                       /**
+                        * {@inheritdoc IResult.(orDefault:2)}
+                        */
+                       orDefault(): T | undefined;
+                       /**
+                        * {@inheritdoc IResult.getValueOrThrow}
+                        * @deprecated Use {@link Success.orThrow | orThrow} instead.
+                        */
+                       getValueOrThrow(__logger?: IResultLogger): T;
+                       /**
+                        * {@inheritdoc IResult.getValueOrDefault}
+                        * @deprecated Use {@link Success.(orDefault:1) | orDefault(T)} or {@link Success.(orDefault:2) | orDefault()} instead.
+                        */
+                       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>;
+                       /**
+                        * {@inheritdoc IResult.aggregateError}
+                        */
+                       aggregateError(errors: IMessageAggregator): this;
+                   }
+
                    /**
-                    * {@inheritdoc IResult.onSuccess}
+                    * Continuation callback to be called in the event that an
+                    * {@link Result} is successful.
+                    * @public
                     */
-                   onSuccess<TN>(cb: SuccessContinuation<T, TN>): Result<TN>;
+                   export declare type SuccessContinuation<T, TN> = (value: T) => Result<TN>;
+
                    /**
-                    * {@inheritdoc IResult.onFailure}
+                    * 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 | Converter} returning `string`.
+                    * @public
                     */
-                   onFailure(__: FailureContinuation<T>): Result<T>;
+                   declare function templateString(defaultContext?: unknown): StringConverter<string, unknown>;
+
                    /**
-                    * {@inheritdoc IResult.withFailureDetail}
+                    * Helper to create a {@link Converter | Converter} which converts a source object to a new object with a
+                    * different shape.
+                    *
+                    * @remarks
+                    * On successful conversion, the resulting {@link Converter | Converter} returns {@link Success | Success} with a new
+                    * object, which contains the converted values under the key names specified at initialization time.
+                    * It returns {@link Failure | 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 | Converter} with the specified conversion behavior.
+                    * @public
                     */
-                   withFailureDetail<TD>(__detail: TD): DetailedResult<T, TD>;
+                   declare function transform<T, TC = unknown>(properties: FieldConverters<T, TC>): Converter<T, TC>;
+
                    /**
-                    * {@inheritdoc IResult.withDetail}
+                    * Helper to create a strongly-typed {@link Converter | Converter} which converts a source object to a
+                    * new object with a different shape.
+                    *
+                    * @remarks
+                    * On successful conversion, the resulting {@link Converter | Converter} returns {@link Success | Success} with a new
+                    * object, which contains the converted values under the key names specified at initialization time.
+                    *
+                    * It returns {@link Failure | 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 or validator used for each source
+                    * property and any other configuration to guide the conversion.
+                    * @param options - Options which affect the transformation.
+                    *
+                    * @returns A {@link Converter | Converter} with the specified conversion behavior.
+                    * @public
                     */
-                   withDetail<TD>(detail: TD, successDetail?: TD): DetailedResult<T, TD>;
-               }
+                   declare function transformObject<TSRC, TDEST, TC = unknown>(destinationFields: FieldTransformers<TSRC, TDEST, TC>, options?: TransformObjectOptions<TSRC>): Converter<TDEST, TC>;
 
-               /**
-                * 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 | Converter} returning `string`.
-                * @public
-                */
-               declare function templateString(defaultContext?: unknown): StringConverter<string, unknown>;
-
-               /**
-                * Helper to create a {@link Converter | Converter} which converts a source object to a new object with a
-                * different shape.
-                *
-                * @remarks
-                * On successful conversion, the resulting {@link Converter | Converter} returns {@link Success | Success} with a new
-                * object, which contains the converted values under the key names specified at initialization time.
-                * It returns {@link Failure | 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 | 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 | Converter} which converts a source object to a
-                * new object with a different shape.
-                *
-                * @remarks
-                * On successful conversion, the resulting {@link Converter | Converter} returns {@link Success | Success} with a new
-                * object, which contains the converted values under the key names specified at initialization time.
-                *
-                * It returns {@link Failure | 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 or validator used for each source
-                * property and any other configuration to guide the conversion.
-                * @param options - Options which affect the transformation.
-                *
-                * @returns A {@link Converter | 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> {
                    /**
-                    * If `strict` is `true` then unused properties in the source object cause
-                    * an error, otherwise they are ignored.
+                    * Options for a {@link Converters.transformObject} call.
+                    * @public
                     */
-                   strict: true;
+                   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;
+                   }
+
                    /**
-                    * An optional list of source properties to be ignored when strict mode
-                    * is enabled.
+                    * An in-place {@link Validation.Validator | Validator} that can be instantiated using a type guard
+                    * function.
+                    * @public
                     */
-                   ignore?: (keyof TSRC)[];
+                   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>;
+                   }
+
                    /**
-                    * An optional description of this transform to be used for error messages.
+                    * Parameters used to construct a {@link Validation.Classes.TypeGuardValidator}.
+                    * @public
                     */
-                   description?: string;
-               }
+                   declare interface TypeGuardValidatorConstructorParams<T, TC = unknown> extends ValidatorBaseConstructorParams<T, TC> {
+                       guard: TypeGuardWithContext<T, TC>;
+                       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> {
                    /**
-                    * {@link Validation.ValidatorOptions | Options} which apply to this
-                    * validator.
+                    * A type guard function which validates a specific type, with an optional context
+                    * that can be used to shape the validation.
+                    * @public
                     */
-                   readonly options: ValidatorOptions<TC>;
-                   readonly description: string;
-                   protected readonly _guard: TypeGuardWithContext<T, TC>;
+                   declare type TypeGuardWithContext<T, TC = unknown> = (from: unknown, context?: TC) => from is T;
+
                    /**
-                    * 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}.
+                    * Helper function to create a {@link Converter | Converter} from any {@link Validation.Validator}
+                    * @param validator - the validator to be wrapped
+                    * @returns A {@link Converter | Converter} which uses the supplied validator.
+                    * @public
                     */
-                   constructor(params: TypeGuardValidatorConstructorParams<T, TC>);
+                   declare function validated<T, TC = unknown>(validator: Validator<T, TC>): Converter<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
+                    * Helper function to create  a {@link Converter | 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 | Converter} returns {@link Success | Success} with the supplied
+                    * value of `from` coerced to type `<T>`.  Returns a {@link Failure | 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
                     */
-                   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 | Converter} from any {@link Validation.Validator}
-                * @param validator - the validator to be wrapped
-                * @returns A {@link Converter | 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 | 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 | Converter} returns {@link Success | Success} with the supplied
-                * value of `from` coerced to type `<T>`.  Returns a {@link Failure | 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
+                   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> {
-                   /**
-                    * {@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.
+                    * In-place validation that a supplied unknown matches some
+                    * required characteristics (type, values, etc).
+                    * @public
                     */
-                   readonly brand: string | undefined;
-                   /**
-                    * Tests to see if a supplied `unknown` value matches this validation.  All
-                    * validate calls are guaranteed to return the entity passed in on Success.
-                    * @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.
+                   export declare interface Validator<T, TC = undefined> {
+                       /**
+                        * {@link Validation.ValidatorTraits | Traits} describing this validation.
                         */
-                    validate(from: unknown, context?: TC): Result<T>;
-                    /**
-                     * Tests to see if a supplied 'unknown' value matches this validation.  In
-                     * contrast to {@link Validator.validate | validate}, makes no guarantees
-                     * about the identity of the returned value.
-                     * @param from - The `unknown` value to be tested.
-                     * @param context - Optional validation context.
-                     * @returns {@link Success} with the typed, conversion value,
-                         * or {@link Failure} with an error message if conversion fails.
-                         */
-                     convert(from: unknown, context?: TC): Result<T>;
-                     /**
-                      * Tests to see if a supplied `unknown` value matches this
-                      * validation.  Accepts `undefined`.
-                      * @param from - The `unknown` value to be tested.
-                      * @param context - Optional validation context.
-                      * @returns {@link Success} with the typed, validated value,
-                          * or {@link Failure} with an error message if validation fails.
-                          */
-                      validateOptional(from: unknown, context?: TC): Result<T | undefined>;
-                      /**
-                       * Non-throwing type guard
-                       * @param from - The value to be tested.
-                       * @param context - Optional validation context.
-                       */
-                      guard(from: unknown, context?: TC): from is T;
-                      /**
-                       * Creates an {@link Validation.Validator | in-place validator}
-                       * which is derived from this one but which also matches `undefined`.
-                       */
-                      optional(): Validator<T | undefined, TC>;
-                      /**
-                       * Creates an {@link Validation.Validator | in-place validator}
-                       * which is derived from this one but which applies additional constraints.
-                       * @param constraint - the constraint to be applied
-                       * @param trait - As optional {@link Validation.ConstraintTrait | ConstraintTrait}
-                       * to be applied to the resulting {@link Validation.Validator | Validator}.
-                       * @returns A new {@link Validation.Validator | Validator}.
-                       */
-                      withConstraint(constraint: Constraint<T>, trait?: ConstraintTrait): Validator<T, TC>;
-                      /**
-                       * Creates a new {@link Validation.Validator | in-place validator} which
-                       * is derived from this one but which matches a branded result.
-                       * @param brand - The brand to be applied.
-                       */
-                      withBrand<B extends string>(brand: B): Validator<Brand<T, B>, TC>;
-                     }
-
-                     /**
-                      * Abstract base helper class for specific validator implementations
-                      * @internal
-                      */
-                     declare abstract class ValidatorBase<T, TC = undefined> extends GenericValidator<T, TC> {
-                         /**
-                          * Inner constructor
-                          * @param params - Initialization params.
-                          * @internal
-                          */
-                         protected constructor(params: Partial<ValidatorBaseConstructorParams<T, TC>>);
+                       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.  All
+                        * validate calls are guaranteed to return the entity passed in on Success.
+                        * @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.  In
+                         * contrast to {@link Validator.validate | validate}, makes no guarantees
+                         * about the identity of the returned value.
+                         * @param from - The `unknown` value to be tested.
+                         * @param context - Optional validation context.
+                         * @returns {@link Success} with the typed, conversion value,
+                             * or {@link Failure} with an error message if conversion fails.
+                             */
+                         convert(from: unknown, context?: TC): Result<T>;
                          /**
-                          * Abstract validation method to me implemented by derived classes.
-                          * @param from - Value to be converted.
+                          * 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 `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>;
-                     }
-
-                     /**
-                      * @internal
-                      */
-                     declare type ValidatorBaseConstructorParams<T, TC> = Omit<GenericValidatorConstructorParams<T, TC>, 'validator'>;
-
-                     /**
-                      * Type for a validation function, which validates that a supplied `unknown`
-                      * value is a valid value of type `<T>`, possibly as influenced by
-                      * an optionally-supplied validation context of type `<TC>`.
-                      * @public
-                      */
-                     declare type ValidatorFunc<T, TC> = (from: unknown, context?: TC) => boolean | Failure<T>;
-
-                     /**
-                      * Options that apply to any {@link Validation.Validator | Validator}.
-                      * @public
-                      */
-                     declare interface ValidatorOptions<TC> {
-                         defaultContext?: TC;
-                     }
-
-                     declare namespace Validators {
-                         export {
-                             object_2 as object,
-                             arrayOf_2 as arrayOf,
-                             enumeratedValue_2 as enumeratedValue,
-                             literal_2 as literal,
-                             oneOf_2 as oneOf,
-                             isA_2 as isA,
-                             string_2 as string,
-                             number_2 as number,
-                             boolean_2 as boolean
+                          * @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>;
                          }
-                     }
-                     export { Validators }
 
-                     /**
-                      * Generic implementation of {@link Validation.ValidatorTraitValues | ValidatorTraitValues}.
-                      * @public
-                      */
-                     declare class ValidatorTraits implements ValidatorTraitValues {
                          /**
-                          * {@inheritdoc Validation.ValidatorTraitValues.isOptional}
+                          * Abstract base helper class for specific validator implementations
+                          * @internal
                           */
-                         readonly isOptional: boolean;
+                         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>;
+                         }
+
                          /**
-                          * {@inheritdoc Validation.ValidatorTraitValues.brand}
+                          * @internal
                           */
-                         readonly brand?: string;
+                         declare type ValidatorBaseConstructorParams<T, TC> = Omit<GenericValidatorConstructorParams<T, TC>, 'validator'>;
+
                          /**
-                          * {@inheritdoc Validation.ValidatorTraitValues.constraints}
+                          * 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
                           */
-                         readonly constraints: ConstraintTrait[];
+                         declare type ValidatorFunc<T, TC> = (from: unknown, context?: TC) => boolean | Failure<T>;
+
                          /**
-                          * 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.
+                          * Options that apply to any {@link Validation.Validator | Validator}.
+                          * @public
                           */
-                         constructor(init?: Partial<ValidatorTraitValues>, base?: ValidatorTraitValues);
-                     }
+                         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,
+                                 oneOf_2 as oneOf,
+                                 isA_2 as isA,
+                                 string_2 as string,
+                                 number_2 as number,
+                                 boolean_2 as boolean
+                             }
+                         }
+                         export { Validators }
 
-                     /**
-                      * Interface describing the supported validator traits.
-                      * @public
-                      */
-                     declare interface ValidatorTraitValues {
                          /**
-                          * Indicates whether the validator accepts `undefined` as
-                          * a valid value.
+                          * Generic implementation of {@link Validation.ValidatorTraitValues | ValidatorTraitValues}.
+                          * @public
                           */
-                         readonly isOptional: boolean;
+                         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);
+                         }
+
                          /**
-                          * If present, indicates that the result will be branded
-                          * with the corresponding brand.
+                          * Interface describing the supported validator traits.
+                          * @public
                           */
-                         readonly brand?: string;
+                         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[];
+                         }
+
                          /**
-                          * Zero or more additional {@link Validation.ConstraintTrait | ConstraintTrait}s
-                          * describing additional constraints applied by this {@link Validation.Validator | Validator}.
+                          * Deprecated alias for @see literal
+                          * @param value - The value to be compared.
+                          * @deprecated Use {@link Converters.literal} instead.
+                          * @internal
                           */
-                         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;
+                         declare const value: typeof literal;
 
-                     export { }
+                         export { }