@fgv/ts-utils 5.0.2 → 5.1.0-1

package/lib/packlets/conversion/converters.d.ts

@@ -1,536 +1,3 @@
-import { TypeGuardWithContext, Validator } from '../validation';
-import { ConverterFunc } from './baseConverter';
-import { Converter, OnError } from './converter';
-import { FieldConverters, ObjectConverter, ObjectConverterOptions } from './objectConverter';
-import { StringConverter } from './stringConverter';
-/**
- * Action to take on conversion failures (deprecated - use Conversion.OnError)
- * @public
- * @deprecated use Conversion.OnError.
- */
-export { OnError };
-/**
- * A converter to convert unknown to string. Values of type
- * string succeed.  Anything else fails.
- * @public
- */
-export declare const string: StringConverter;
-/**
- * Helper function to create a {@link Converter | Converter} which converts `unknown` to one of a set of supplied
- * enumerated values. Anything else fails.
- *
- * @remarks
- * Allowed enumerated values can also be supplied as context at conversion time.
- * @param values - Array of allowed values.
- * @returns A new {@link Converter | Converter} returning `<T>`.
- * @public
- */
-export declare function enumeratedValue<T>(values: ReadonlyArray<T>): Converter<T, ReadonlyArray<T>>;
-/**
- * Helper function to create a {@link Converter | Converter} which converts `unknown` to one of a set of supplied enumerated
- * values, mapping any of multiple supplied values to the enumeration.
- * @remarks
- * Enables mapping of multiple input values to a consistent internal representation (so e.g. `'y'`, `'yes'`,
- * `'true'`, `1` and `true` can all map to boolean `true`)
- * @param map - An array of tuples describing the mapping. The first element of each tuple is the result
- * value, the second is the set of values that map to the result.  Tuples are evaluated in the order
- * supplied and are not checked for duplicates.
- * @param message - An optional error message.
- * @returns A {@link Converter | Converter} which applies the mapping and yields `<T>` on success.
- * @public
- */
-export declare function mappedEnumeratedValue<T, TC = unknown>(map: ReadonlyArray<[T, ReadonlyArray<TC>]>, message?: string): Converter<T, ReadonlyArray<TC>>;
-/**
- * Helper function to create a {@link Converter | Converter} which converts `unknown` to some supplied literal value. Succeeds with
- * the supplied value if an identity comparison succeeds, fails otherwise.
- * @param value - The value to be compared.
- * @returns A {@link Converter | Converter} which returns the supplied value on success.
- * @public
- */
-export declare function literal<T, TC = unknown>(value: T): Converter<T, TC>;
-/**
- * Deprecated alias for @see literal
- * @param value - The value to be compared.
- * @deprecated Use {@link Converters.literal} instead.
- * @internal
- */
-export declare const value: typeof literal;
-/**
- * A {@link Converter | Converter} which converts `unknown` to a `number`.
- * @remarks
- * Numbers and strings with a numeric format succeed. Anything else fails.
- * @public
- */
-export declare const number: Converter<number, unknown>;
-/**
- * A {@link Converter | Converter} which converts `unknown` to `boolean`.
- * @remarks
- * Boolean values or the case-insensitive strings `'true'` and `'false'` succeed.
- * Anything else fails.
- * @public
- */
-export declare const boolean: Converter<boolean, unknown>;
-/**
- * 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
- */
-export declare const optionalString: Converter<string | undefined, unknown>;
-/**
- * Helper function to create a {@link Converter | Converter} which converts any `string` into an
- * array of `string`, by separating at a supplied delimiter.
- * @remarks
- * Delimiter may also be supplied as context at conversion time.
- * @param delimiter - The delimiter at which to split.
- * @returns A new {@link Converter | Converter} returning `string[]`.
- * @public
- */
-export declare function delimitedString(delimiter: string, options?: 'filtered' | 'all'): Converter<string[], string>;
-/**
- * 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
- */
-export declare function validated<T, TC = unknown>(validator: Validator<T, TC>): Converter<T, TC>;
-/**
- * Helper function to create a {@link Converter | Converter} from a supplied {@link Conversion.ConverterFunc | ConverterFunc}.
- * @param convert - the function to be wrapped
- * @returns A {@link Converter | Converter} which uses the supplied function.
- * @public
- */
-export declare function generic<T, TC = unknown>(convert: ConverterFunc<T, TC>): Converter<T, TC>;
-/**
- * Helper function to create a {@link Converter | Converter} from a supplied type guard function.
- * @param description - a description of the thing to be validated for use in error messages
- * @param guard - a {@link Validation.TypeGuardWithContext} which performs the validation.
- * @returns A new {@link Converter | Converter} which validates the values using the supplied type guard
- * and returns them in place.
- * @public
- */
-export declare function isA<T, TC = unknown>(description: string, guard: TypeGuardWithContext<T, TC>): Converter<T, TC>;
-/**
- * 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
- */
-export declare const optionalNumber: Converter<number | undefined, unknown>;
-/**
- * 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
- */
-export declare const optionalBoolean: Converter<boolean | undefined, unknown>;
-/**
- * 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 oneOf<T, TC = unknown>(converters: Array<Converter<T, TC> | Validator<T, TC>>, onError?: OnError): Converter<T, TC>;
-/**
- * A helper function to create a {@link Converter | Converter} which converts `unknown` to an array of `<T>`.
- * @remarks
- * If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot
- * be converted.  If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.
- * @param converter - {@link Converter | Converter} or {@link Validator | Validator} used to convert each
- * item in the array.
- * @param ignoreErrors - Specifies treatment of unconvertible elements.
- * @returns A {@link Converter | Converter} which returns an array of `<T>`.
- * @public
- */
-export declare function arrayOf<T, TC = unknown>(converter: Converter<T, TC> | Validator<T, TC>, onError?: OnError): Converter<T[], TC>;
-/**
- * {@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
- */
-export declare const stringArray: Converter<string[], unknown>;
-/**
- * {@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
- */
-export declare const numberArray: Converter<number[], unknown>;
-/**
- * Options for {@link Converters.(recordOf:3) | Converters.recordOf} and
- * {@link Converters.(mapOf:3) | Converters.mapOf}
- * helper functions.
- * @public
- */
-export interface KeyedConverterOptions<T extends string = string, TC = unknown> {
-    /**
-     * if `onError` is `'fail'` (default), then the entire conversion fails if any key or element
-     * cannot be converted.  If `onError` is `'ignore'`, failing elements are silently ignored.
-     */
-    onError?: 'fail' | 'ignore';
-    /**
-     * If present, `keyConverter` is used to convert the source object property names to
-     * keys in the resulting map or record.
-     * @remarks
-     * Can be used to coerce key names to supported values and/or strong types.
-     */
-    keyConverter?: Converter<T, TC> | Validator<T, TC>;
-}
-/**
- * A helper function to create a {@link Converter | Converter} which converts the `string`-keyed
- * properties using a supplied {@link Converter | Converter<T, TC>} 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
- */
-export declare function recordOf<T, TC = unknown, 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, TC>} 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
- */
-export declare function recordOf<T, TC = unknown, 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, TC>} 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
- */
-export declare function recordOf<T, TC = unknown, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>, options: KeyedConverterOptions<TK, 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, TC>} or {@link Validator | Validator<T>} to produce a
- * `Map<string, T>`.
- * @remarks
- * The resulting converter fails conversion if any element cannot be converted.
- * @param converter - {@link Converter | Converter} | {@link Validator | Validator} used for each item in
- * the source object.
- * @returns A {@link Converter | Converter} which returns `Map<string, T>`.
- * {@label WITH_DEFAULT}
- * @public
- */
-export declare function mapOf<T, TC = unknown, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>): Converter<Map<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, TC>} or {@link Validator | Validator<T>} to produce a
- * `Map<string, T>` and 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} used for
- * each item in the source object.
- * @returns A {@link Converter | Converter} which returns `Map<string, T>`.
- * {@label WITH_ON_ERROR}
- * @public
- */
-export declare function mapOf<T, TC = unknown, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>, onError: 'fail' | 'ignore'): Converter<Map<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, TC>} or {@link Validator | Validator<T>} to produce
- * a `Map<TK,T>`.
- * @remarks
- * If present, the supplied {@link Converters.KeyedConverterOptions | options} can provide a strongly-typed
- * converter for keys and/or control the handling of elements that fail conversion.
- * @param converter - {@link Converter | 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 `Map<TK,T>`.
- * {@label WITH_OPTIONS}
- * @public
- */
-export declare function mapOf<T, TC = unknown, TK extends string = string>(converter: Converter<T, TC> | Validator<T, TC>, options: KeyedConverterOptions<TK, TC>): Converter<Map<TK, 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, TC>} which applies the supplied validation.
- * @public
- */
-export declare function validateWith<T, TC = unknown>(validator: (from: unknown) => from is T, description?: string): Converter<T, TC>;
-/**
- * A helper function to create a {@link Converter | Converter} which extracts and converts an element from an array.
- * @remarks
- * The returned {@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 Failure | Failure} with an error message otherwise.
- * @param index - The index of the element to be extracted.
- * @param converter - A {@link Converter | Converter} or {@link Validator | Validator} for the extracted element.
- * @returns A {@link Converter | Converter<T, TC>} which extracts the specified element from an array.
- * @public
- */
-export declare function element<T, TC = unknown>(index: number, converter: Converter<T, TC> | Validator<T, TC>): Converter<T, TC>;
-/**
- * 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, TC>} which extracts the specified element from an array.
- * @public
- */
-export declare function optionalElement<T, TC = unknown>(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 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
- */
-export declare function field<T, TC = unknown>(name: string, converter: Converter<T, TC> | Validator<T, TC>): Converter<T, 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
- */
-export declare function optionalField<T, TC = unknown>(name: string, converter: Converter<T, TC> | Validator<T, TC>): Converter<T | undefined, TC>;
-/**
- * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter<T, TC>} which converts an object
- * without changing shape, given a {@link Conversion.FieldConverters | FieldConverters<T, TC>} 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, TC>} 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
- */
-export declare function object<T, TC = unknown>(properties: FieldConverters<T, TC>, options?: ObjectConverterOptions<T>): ObjectConverter<T, TC>;
-/**
- * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter<T, TC>} which converts an object
- * without changing shape, given a {@link Conversion.FieldConverters | FieldConverters<T, TC>} 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, TC>} 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.
- */
-export declare function object<T, TC = unknown>(properties: FieldConverters<T, TC>, optional: (keyof T)[]): ObjectConverter<T, TC>;
-/**
- * Options for the {@link Converters.(strictObject:1)} helper function.
- * @public
- */
-export type StrictObjectConverterOptions<T> = Omit<ObjectConverterOptions<T>, 'strict'>;
-/**
- * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter} which converts an object
- * without changing shape, a {@link Conversion.FieldConverters | FieldConverters<T, TC>} 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
- */
-export declare function strictObject<T, TC = unknown>(properties: FieldConverters<T, TC>, options?: StrictObjectConverterOptions<T>): ObjectConverter<T, TC>;
-/**
- * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter} which converts an object
- * without changing shape, a {@link Conversion.FieldConverters | FieldConverters<T, TC>} 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
- */
-export declare function strictObject<T, TC = unknown>(properties: FieldConverters<T, TC>, optional: (keyof T)[]): ObjectConverter<T, TC>;
-/**
- * A string-keyed `Record<string, Converter>` which maps specific {@link Converter | converters} or
- * {@link Validator | Validators} to the value of a discriminator property.
- * @public
- */
-export type DiscriminatedObjectConverters<T, TD extends string = string, TC = unknown> = Record<TD, Converter<T, TC> | Validator<T, TC>>;
-/**
- * Helper to create a {@link Converter | Converter} which converts a discriminated object without changing shape.
- * @remarks
- * Takes the name of the discriminator property and a
- * {@link Converters.DiscriminatedObjectConverters | string-keyed Record of converters and validators}. During conversion,
- * the resulting {@link Converter | Converter} invokes the converter from `converters` that corresponds to the value of
- * the discriminator property in the source object.
- *
- * If the source is not an object, the discriminator property is missing, or the discriminator has
- * a value not present in the converters, conversion fails and returns {@link Failure | Failure} with more information.
- * @param discriminatorProp - Name of the property used to discriminate types.
- * @param converters - {@link Converters.DiscriminatedObjectConverters | String-keyed record of converters and validators}
- * to invoke, where each key corresponds to a value of the discriminator property.
- * @returns A {@link Converter | Converter} which converts the corresponding discriminated object.
- * @public
- */
-export declare function discriminatedObject<T, TD extends string = string, TC = unknown>(discriminatorProp: string, converters: DiscriminatedObjectConverters<T, TD>): Converter<T, TC>;
-/**
- * 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
- */
-export declare function transform<T, TC = unknown>(properties: FieldConverters<T, TC>): Converter<T, TC>;
-/**
- * Per-property converters and configuration for each field in the destination object of
- * a {@link Converters.transformObject} call.
- * @public
- */
-export type FieldTransformers<TSRC, TDEST, TC = unknown> = {
-    [key in keyof TDEST]: {
-        /**
-         * The name of the property in the source object to be converted.
-         */
-        from: keyof TSRC;
-        /**
-         * The converter or validator used to convert the property.
-         */
-        converter: Converter<TDEST[key], TC> | Validator<TDEST[key], TC>;
-        /**
-         * If `true` then a missing source property is ignored.  If `false` or omitted
-         * then a missing source property causes an error.
-         */
-        optional?: boolean;
-    };
-};
-/**
- * Options for a {@link Converters.transformObject} call.
- * @public
- */
-export 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;
-}
-/**
- * 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
- */
-export declare function transformObject<TSRC, TDEST, TC = unknown>(destinationFields: FieldTransformers<TSRC, TDEST, TC>, options?: TransformObjectOptions<TSRC>): Converter<TDEST, TC>;
+export * from './basicConverters';
+export * from './advancedConverters';
 //# sourceMappingURL=converters.d.ts.map