import { Brand, Result, Success } from '../base';
import { ConstraintOptions, ConversionErrorFormatter, Converter, DefaultingConverter } from './converter';
/**
 * Generic {@link Conversion.DefaultingConverter | DefaultingConverter}, which wraps another converter
 * to substitute a supplied default value for any errors returned by the inner converter.
 * @public
 */
export declare class GenericDefaultingConverter<T, TD = T, TC = unknown> implements DefaultingConverter<T, TD, TC> {
    private _converter;
    /**
     * {@inheritdoc Conversion.DefaultingConverter.defaultValue}
     */
    defaultValue: TD;
    /**
     * {@inheritdoc Converter.isOptional}
     */
    get isOptional(): boolean;
    /**
     * {@inheritdoc Converter.isOptional}
     */
    get brand(): string | undefined;
    /**
     * Constructs a new {@link Conversion.GenericDefaultingConverter | generic defaulting converter}.
     * @param converter - inner {@link Converter | Converter} used for the base conversion.
     * @param defaultValue - default value to be supplied if the inner conversion fails.
     */
    constructor(converter: Converter<T, TC>, defaultValue: TD);
    /**
     * {@inheritdoc Converter.convert}
     */
    convert(from: unknown, ctx?: TC | undefined): Success<T | TD>;
    /**
     * {@inheritdoc Converter.convertOptional}
     */
    convertOptional(from: unknown, context?: TC | undefined, onError?: ('failOnError' | 'ignoreErrors') | undefined): Result<T | TD | undefined>;
    /**
     * {@inheritdoc Converter.optional}
     */
    optional(onError?: ('failOnError' | 'ignoreErrors') | undefined): Converter<T | TD | undefined, TC>;
    /**
     * {@inheritdoc Converter.map}
     */
    map<T2>(mapper: (from: T | TD) => Result<T2>): Converter<T2, TC>;
    /**
     * {@inheritdoc Converter.mapConvert}
     */
    mapConvert<T2>(mapConverter: Converter<T2, unknown>): Converter<T2, TC>;
    /**
     * {@inheritdoc Converter.mapItems}
     */
    mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC>;
    /**
     * {@inheritdoc Converter.mapConvertItems}
     */
    mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;
    /**
     * {@inheritdoc Converter.withAction}
     */
    withAction<T2>(action: (result: Result<T | TD>) => Result<T2>): Converter<T2, TC>;
    /**
     * {@inheritdoc Converter.withTypeGuard}
     */
    withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string | undefined): Converter<TI, TC>;
    /**
     * {@inheritdoc Converter.withItemTypeGuard}
     */
    withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string | undefined): Converter<TI[], TC>;
    /**
     * {@inheritdoc Converter.withConstraint}
     */
    withConstraint(constraint: (val: T | TD) => boolean | Result<T | TD>, options?: ConstraintOptions | undefined): Converter<T | TD, TC>;
    /**
     * {@inheritdoc Converter.withBrand}
     */
    withBrand<B extends string>(brand: B): Converter<Brand<T | TD, B>, TC>;
    /**
     * {@inheritdoc Converter.withFormattedError}
     */
    withFormattedError(formatter: ConversionErrorFormatter<TC>): Converter<T | TD, TC>;
    /**
     * Returns a Converter which always succeeds with the supplied default value rather
     * than failing.
     *
     * Note that the supplied default value *overrides* the default value of this
     * {@link Conversion.DefaultingConverter | DefaultingConverter}.
     */
    withDefault<TD2 = T>(dflt: TD2): DefaultingConverter<T, TD2, TC>;
    private _applyDefault;
}
//# sourceMappingURL=defaultingConverter.d.ts.map