import { type GetterOrValue } from '../getter/getter';
import { type Maybe, type MaybeSo } from '../value/maybe.type';
import { type ApplyMapFunctionWithOptions, type MapFunction } from '../value/map';
import { type MergeReplace, type ReplaceType } from '../type';
import { type XOR } from 'ts-essentials';
/**
 * Type used to declare a sister-type to the generic object.
 */
export type MappedModelData<I extends object, R extends object> = MergeReplace<I, R>;
export type TypedMappedModelData<I extends object, O extends object, X = any> = ReplaceType<I, O, X>;
export type ModelMapFunction<I extends object, O extends object> = ApplyMapFunctionWithOptions<Maybe<I>, O, ModelConversionOptions<I>>;
export type ModelMapFromFunction<V extends object, D extends object> = ModelMapFunction<D, V>;
export type ModelMapToFunction<V extends object, D extends object> = ModelMapFunction<V, D>;
export interface ModelMapFunctions<V extends object, D extends object> {
    from: ModelMapFromFunction<V, D>;
    to: ModelMapToFunction<V, D>;
}
/**
 * Creates bidirectional map functions (`from` and `to`) from a set of {@link ModelFieldConversions}.
 *
 * The `to` function converts from the model (V) to data (D), while `from` converts back from data (D) to model (V).
 *
 * @param fields - Field conversion definitions for each key in the model
 * @returns Object with `from` and `to` mapping functions
 */
export declare function makeModelMapFunctions<V extends object, D extends object>(fields: ModelFieldConversions<V, D>): ModelMapFunctions<V, D>;
export type ModelConversionFieldTuple<I extends object> = [keyof I, ModelFieldMapFunction<unknown, unknown>];
export type ModelConversionFieldValuesConfig<I extends object> = ModelConversionFieldTuple<I>[];
export interface ModelConversionOptions<I extends object> {
    /**
     * Fields to include.
     */
    fields?: (keyof I)[];
    /**
     * Whether or not to only convert fields that are defined. Fields with a null value are still converted.
     */
    definedOnly?: boolean;
}
/**
 * A model conversion function. Performs a conversion on all non-null values.
 */
export type ModelConversionFieldValuesFunction<I extends object, O extends object> = ApplyMapFunctionWithOptions<Maybe<I>, O, ModelConversionOptions<I>>;
/**
 * Creates a conversion function that maps fields from an input object to an output object using per-field conversion functions.
 *
 * Supports optional filtering by field names and skipping undefined values via {@link ModelConversionOptions}.
 *
 * @param fields - Array of `[key, convertFn]` tuples defining how each field is converted
 * @returns A function that converts an input object to an output object
 */
export declare function makeModelConversionFieldValuesFunction<I extends object, O extends object>(fields: ModelConversionFieldValuesConfig<I>): ModelConversionFieldValuesFunction<I, O>;
/**
 * An object map containing a ModelFieldMapFunctions entry for each key (required and optional) from the generic object.
 */
export type ModelFieldConversions<V extends object, D extends object> = Required<{
    [K in keyof V]: ModelFieldMapFunctions<V[K], TypedMappedModelData<V, D>[K]>;
}>;
/**
 * An object map containing a ModelFieldMapFunctionsConfig for each key (required and optional) from the generic object.
 */
export type ModelFieldConversionsConfig<V extends object, D extends object> = Required<{
    [K in keyof V]: ModelFieldMapFunctionsConfig<V[K], TypedMappedModelData<V, D>[K]>;
}>;
/**
 * Converts a {@link ModelFieldConversionsConfig} (with raw config per field) into resolved {@link ModelFieldConversions} (with compiled map functions per field).
 *
 * @param config - Configuration object with a conversion config for each model field
 * @returns Resolved field conversions with compiled `from` and `to` functions
 */
export declare function modelFieldConversions<V extends object, D extends object>(config: ModelFieldConversionsConfig<V, D>): ModelFieldConversions<V, D>;
export type ModelFieldMapFunctions<I = unknown, O = unknown> = {
    readonly from: ModelFieldMapFromFunction<I, O>;
    readonly to: ModelFieldMapToFunction<I, O>;
};
export type ModelFieldMapFunctionsConfig<I = unknown, O = unknown> = {
    readonly from: ModelFieldMapFromConfig<I, O>;
    readonly to: ModelFieldMapToConfig<I, O>;
};
export type ModelFieldMapFunctionsWithDefaultsConfig<I = unknown, O = unknown> = {
    readonly from: ModelFieldMapFromWithDefaultConfig<I, O>;
    readonly to: ModelFieldMapToWithDefaultConfig<I, O>;
};
/**
 * Compiles a {@link ModelFieldMapFunctionsConfig} into resolved {@link ModelFieldMapFunctions} with `from` and `to` mapping functions.
 *
 * @param config - Configuration with `from` and `to` field map configs
 * @returns Compiled field map functions
 */
export declare function modelFieldMapFunctions<I = unknown, O = unknown>(config: ModelFieldMapFunctionsConfig<I, O>): ModelFieldMapFunctions<I, O>;
/**
 * ModelFieldMapFunction configuration that can convert a MaybeValue to the target value.
 */
export type ModelFieldMapMaybeTooConfig<I, O> = {
    convertMaybe: ModelFieldMapConvertMaybeFunction<I, O>;
};
export type ModelFieldMapMaybeWithDefaultValueConfig<I, O> = {
    defaultInput: GetterOrValue<I>;
    convert: ModelFieldMapConvertFunction<I, O>;
};
export type ModelFieldMapMaybeWithDefaultDataConfig<I, O> = {
    convert: ModelFieldMapConvertFunction<I, O>;
    default: GetterOrValue<O>;
};
export type ModelFieldMapConvertMaybeFunction<I, O> = MapFunction<Maybe<I>, O>;
export type ModelFieldMapConvertFunction<I, O> = MapFunction<MaybeSo<I>, O>;
/**
 * ModelFieldMapFunction configuration that handles the MaybeNot case with undefined.
 */
export type ModelFieldMapMaybeWithDefaultConfig<I, O> = ModelFieldMapMaybeWithDefaultValueConfig<I, O> | ModelFieldMapMaybeWithDefaultDataConfig<I, O>;
/**
 * Configuration is either a ModelFieldMapMaybeTooConfig or a ModelFieldMapMaybeWithDefaultConfig
 */
export type ModelFieldMapConfig<I, O> = XOR<ModelFieldMapMaybeTooConfig<I, O>, ModelFieldMapMaybeWithDefaultConfig<I, O>>;
export type ModelFieldMapFromConfig<I = unknown, O = unknown> = ModelFieldMapConfig<O, I>;
export type ModelFieldMapToConfig<I = unknown, O = unknown> = ModelFieldMapConfig<I, O>;
export type ModelFieldMapFromWithDefaultConfig<I = unknown, O = unknown> = ModelFieldMapMaybeWithDefaultConfig<O, I>;
export type ModelFieldMapToWithDefaultConfig<I = unknown, O = unknown> = ModelFieldMapMaybeWithDefaultConfig<I, O>;
export type ModelFieldMapFunction<I = unknown, O = unknown> = MapFunction<Maybe<I>, O>;
export type ModelFieldMapFromFunction<I, O> = ModelFieldMapFunction<O, I>;
export type ModelFieldMapToFunction<I, O> = ModelFieldMapFunction<I, O>;
/**
 * Creates a {@link ModelFieldMapFunction} from a config that handles Maybe input values.
 *
 * The function handles three cases:
 * - Non-null input: uses `convert` to transform the value
 * - Null/undefined input with `convertMaybe`: delegates to that function
 * - Null/undefined input with `default` or `defaultInput`: uses the appropriate fallback
 *
 * @param config - Configuration specifying how to convert values and handle null/undefined
 * @returns A function that maps Maybe input values to output values
 */
export declare function modelFieldMapFunction<I, O>(config: ModelFieldMapConfig<I, O>): ModelFieldMapFunction<I, O>;
export type ModelFieldConversionsConfigRef<T extends object, O extends object> = {
    readonly fields: ModelFieldConversionsConfig<T, O>;
};
export type ModelFieldConversionsRef<T extends object, O extends object> = {
    readonly fieldConversions: ModelFieldConversions<T, O>;
};
export type ToModelFieldConversionsInput<T extends object, O extends object> = ModelFieldConversionsConfigRef<T, O> | ModelFieldConversionsRef<T, O>;
/**
 * Resolves a {@link ToModelFieldConversionsInput} to a {@link ModelFieldConversions} value.
 *
 * Accepts either a pre-built `fieldConversions` reference or a `fields` config that will be compiled.
 *
 * @param input - Either a config ref or a pre-built conversions ref
 * @returns Resolved field conversions
 */
export declare function toModelFieldConversions<T extends object, O extends object>(input: ToModelFieldConversionsInput<T, O>): Required<{ [K in keyof T]: ModelFieldMapFunctions<T[K], ReplaceType<T, O, any>[K]>; }>;
export type ModelMapFunctionsRef<T extends object, O extends object> = {
    readonly mapFunctions: ModelMapFunctions<T, O>;
};
export type ToModelMapFunctionsInput<T extends object, O extends object> = ToModelFieldConversionsInput<T, O> | ModelMapFunctionsRef<T, O>;
/**
 * Resolves a {@link ToModelMapFunctionsInput} to {@link ModelMapFunctions}.
 *
 * Accepts a pre-built `mapFunctions` reference, a `fieldConversions` ref, or a `fields` config.
 *
 * @param input - Input that can be resolved to model map functions
 * @returns Bidirectional model map functions
 */
export declare function toModelMapFunctions<T extends object, O extends object>(input: ToModelMapFunctionsInput<T, O>): ModelMapFunctions<T, O>;