import { Brand, Result } from '../base';
import { ConstraintOptions, ConversionErrorFormatter, Converter, ConverterTraits, DefaultingConverter, OnError } from './converter';
/**
 * internal
 */
type InnerInferredType<TCONV> = TCONV extends Converter<infer TTO> ? TTO extends Array<infer TTOELEM> ? InnerInferredType<TTOELEM>[] : TTO : TCONV extends Array<infer TELEM> ? InnerInferredType<TELEM>[] : TCONV;
/**
 * Infers the type that will be returned by an instantiated converter.  Works
 * for complex as well as simple types.
 * @example `Infer<typeof Converters.mapOf(Converters.stringArray)>` is `Map<string, string[]>`
 * @beta
 */
export type Infer<TCONV> = TCONV extends Converter<infer TTO, unknown> ? InnerInferredType<TTO> : never;
/**
 * Deprecated name for Infer<T> retained for compatibility
 * @deprecated use @see Infer instead
 * @internal
 */
export type ConvertedToType<TCONV> = Infer<TCONV>;
/**
 * Function signature for a converter function.
 * @public
 */
export type ConverterFunc<T, TC> = (from: unknown, self: Converter<T, TC>, context?: TC) => Result<T>;
/**
 * Base templated wrapper to simplify creation of new {@link Converter}s.
 * @public
 */
export declare class BaseConverter<T, TC = unknown> implements Converter<T, TC> {
    /**
     * @internal
     */
    protected readonly _defaultContext?: TC;
    /**
     * @internal
     */
    protected _isOptional: boolean;
    /**
     * @internal
     */
    protected _brand?: string;
    private readonly _converter;
    /**
     * Constructs a new {@link Converter} which uses the supplied function to perform the conversion.
     * @param converter - The conversion function to be applied.
     * @param defaultContext - Optional conversion context to be used by default.
     * @param traits - Optional {@link Conversion.ConverterTraits | traits} to be assigned to the resulting
     * converter.
     */
    constructor(converter: ConverterFunc<T, TC>, defaultContext?: TC, traits?: ConverterTraits);
    /**
     * {@inheritdoc Converter.isOptional}
     */
    get isOptional(): boolean;
    /**
     * {@inheritdoc Converter.brand}
     */
    get brand(): string | undefined;
    /**
     * {@inheritdoc Converter.convert}
     */
    convert(from: unknown, context?: TC): Result<T>;
    /**
     * {@inheritdoc Converter.convertOptional}
     */
    convertOptional(from: unknown, context?: TC, onError?: OnError): Result<T | undefined>;
    /**
     * {@inheritdoc Converter.optional}
     */
    optional(onError?: OnError): Converter<T | undefined, TC>;
    /**
     * {@inheritdoc Converter.map}
     */
    map<T2>(mapper: (from: T, context?: TC) => Result<T2>): Converter<T2, TC>;
    /**
     * {@inheritdoc Converter.mapConvert}
     */
    mapConvert<T2>(mapConverter: Converter<T2>): Converter<T2, TC>;
    /**
     * {@inheritdoc Converter.mapItems}
     */
    mapItems<TI>(mapper: (from: unknown, context?: TC) => Result<TI>): Converter<TI[], TC>;
    /**
     * {@inheritdoc Converter.mapConvertItems}
     */
    mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;
    /**
     * {@inheritdoc Converter.withAction}
     */
    withAction<TI>(action: (result: Result<T>, context?: TC) => Result<TI>): Converter<TI, TC>;
    /**
     * {@inheritdoc Converter.withTypeGuard}
     */
    withTypeGuard<TI>(guard: (from: unknown, context?: TC) => from is TI, message?: string): Converter<TI, TC>;
    /**
     * {@inheritdoc Converter.withItemTypeGuard}
     */
    withItemTypeGuard<TI>(guard: (from: unknown, context?: TC) => from is TI, message?: string): Converter<TI[], TC>;
    /**
     * {@inheritdoc Converter.withConstraint}
     */
    withConstraint(constraint: (val: T, context?: TC) => boolean | Result<T>, options?: ConstraintOptions): Converter<T, TC>;
    /**
     * {@inheritdoc Converter.withBrand}
     */
    withBrand<B extends string>(brand: B): Converter<Brand<T, B>, TC>;
    /**
     * {@inheritdoc Converter.withDefault}
     */
    withDefault<TD = T>(defaultValue: TD): DefaultingConverter<T, TD, TC>;
    /**
     * @internal
     */
    protected _context(supplied?: TC): TC | undefined;
    /**
     * {@inheritdoc Converter.withFormattedError}
     */
    withFormattedError(formatter: ConversionErrorFormatter<TC>): Converter<T, TC>;
    /**
     * @internal
     */
    protected _traits(traits?: Partial<ConverterTraits>): ConverterTraits;
    /**
     * @internal
     */
    protected _with(traits: Partial<ConverterTraits>): this;
}
export {};
//# sourceMappingURL=baseConverter.d.ts.map