import { SnapshotInOf, SnapshotOutOf } from '../snapshot/SnapshotOf';
import { AnyStandardType } from '../types/schemas';
import { Flatten, IsNeverType, IsOptionalValue } from '../utils/types';
/**
 * @ignore
 */
export declare const noDefaultValue: unique symbol;
type SetterMode = boolean | "assign";
export type ModelPropSetterValueTransform<T> = (value: T) => T;
/**
 * A model property.
 */
export interface ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId extends boolean = false, THasSetter = never, TFromSnapshotOverride = never, TToSnapshotOverride = never> {
    $valueType: TPropValue;
    $creationValueType: TPropCreationValue;
    $transformedValueType: TTransformedValue;
    $transformedCreationValueType: TTransformedCreationValue;
    $isRequired: TIsRequired;
    $isId: TIsId;
    $hasSetter: THasSetter;
    $fromSnapshotOverride: TFromSnapshotOverride;
    $toSnapshotOverride: TToSnapshotOverride;
    _defaultFn: (() => TPropValue) | typeof noDefaultValue;
    _defaultValue: TPropValue | typeof noDefaultValue;
    _defaultValueIsTransformed: boolean;
    _typeChecker: AnyStandardType | undefined;
    _setter: SetterMode;
    _setterValueTransform: ((value: unknown) => unknown) | undefined;
    _isId: boolean;
    _idGenerator?: (() => string) | undefined;
    _transform: {
        transform: (original: unknown, model: object, propName: PropertyKey, setOriginalValue: (newOriginalValue: unknown) => void) => unknown;
        untransform: (transformed: unknown, model: object, propName: PropertyKey) => unknown;
    } | undefined;
    _fromSnapshotProcessor?: (sn: unknown) => unknown;
    _toSnapshotProcessor?: (sn: unknown) => unknown;
    /**
     * Adds a setter to the property. The setter will be named `set${CapitalizedPropName}`
     * and will be available in the model instance.
     */
    withSetter(): ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId, string, TFromSnapshotOverride, TToSnapshotOverride>;
    /**
     * Adds a setter with a transform to the property. The setter will be named `set${CapitalizedPropName}`
     * and will be available in the model instance.
     */
    withSetter(valueTransform: ModelPropSetterValueTransform<TTransformedValue>): ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId, string, TFromSnapshotOverride, TToSnapshotOverride>;
    /**
     * @deprecated Setter methods are preferred.
     */
    withSetter(mode: "assign"): ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId, string, TFromSnapshotOverride, TToSnapshotOverride>;
    /**
     * Sets a transform for the property instance value.
     *
     * @deprecated Prefer using `tProp(types.codec(...))` or one of the built-in codec types
     * (e.g. `types.dateAsTimestamp`, `types.bigint`, `types.mapFromObject(...)`) instead.
     * Wrap with `types.skipCheck(...)` if you don't need runtime validation.
     * Use `.withTransform(...)` only for one-off custom transforms without a codec equivalent.
     *
     * @template TTV Transformed value type.
     * @param transform Transform to be used.
     * @returns
     */
    withTransform<TTV>(transform: ModelPropTransform<NonNullable<TPropValue>, TTV>): ModelProp<TPropValue, TPropCreationValue, TTV | Extract<TPropValue, null | undefined>, TTV | Extract<TPropCreationValue, null | undefined>, TIsRequired, TIsId, THasSetter, TFromSnapshotOverride, TToSnapshotOverride>;
    /**
     * Sets snapshot processors for this property.
     *
     * `fromSnapshot` runs before assigning snapshot data into the model prop.
     * `toSnapshot` runs when exporting model data back to snapshot form.
     */
    withSnapshotProcessor<FS = TFromSnapshotOverride, TS = TToSnapshotOverride, This extends AnyModelProp = this>(processor: {
        fromSnapshot?: (sn: FS) => ModelPropFromSnapshot<This>;
        toSnapshot?: (sn: ModelPropToSnapshot<This>) => TS;
    }): ModelProp<TPropValue, TPropCreationValue, TTransformedValue, TTransformedCreationValue, TIsRequired, TIsId, THasSetter, FS, TS>;
}
/**
 * The snapshot in type of a model property.
 */
export type ModelPropFromSnapshot<MP extends AnyModelProp> = IsNeverType<ModelPropFromSnapshotOverride<MP>, SnapshotInOf<ModelPropStoredCreationValue<MP>>, ModelPropFromSnapshotOverride<MP>>;
/**
 * The snapshot out type of a model property.
 */
export type ModelPropToSnapshot<MP extends AnyModelProp> = IsNeverType<MP["$toSnapshotOverride"], SnapshotOutOf<ModelPropStoredValue<MP>>, MP["$toSnapshotOverride"]>;
export type ModelPropStoredValue<MP extends AnyModelProp> = MP extends {
    $storedValueType: infer TStoredValue;
} ? TStoredValue : MP["$valueType"];
export type ModelPropStoredCreationValue<MP extends AnyModelProp> = MP extends {
    $storedCreationValueType: infer TStoredCreationValue;
} ? TStoredCreationValue : MP["$creationValueType"];
export type ModelPropFromSnapshotOverride<MP extends AnyModelProp> = MP extends {
    $typedFromSnapshotOverride: infer TFromSnapshotOverride;
} ? TFromSnapshotOverride : MP["$fromSnapshotOverride"];
/**
 * A model prop transform.
 */
export interface ModelPropTransform<TOriginal, TTransformed> {
    /**
     * Converts the stored/original value into the transformed value exposed by the model prop.
     */
    transform(params: {
        originalValue: TOriginal;
        cachedTransformedValue: TTransformed | undefined;
        setOriginalValue(value: TOriginal): void;
    }): TTransformed;
    /**
     * Converts the transformed model value back into the original stored value.
     */
    untransform(params: {
        transformedValue: TTransformed;
        cacheTransformedValue: () => void;
    }): TOriginal;
}
/**
 * Any model property.
 */
export type AnyModelProp = ModelProp<any, any, any, any, any, any, any, any, any>;
/**
 * Model properties.
 */
export interface ModelProps {
    [k: string]: AnyModelProp;
}
export type RequiredModelProps<MP extends ModelProps> = {
    [K in keyof MP]: MP[K]["$isRequired"] & K;
}[keyof MP];
export type ModelPropsToUntransformedData<MP extends ModelProps> = Flatten<{
    [k in keyof MP]: ModelPropStoredValue<MP[k]>;
}>;
export type ModelPropsToSnapshotData<MP extends ModelProps> = Flatten<{
    [k in keyof MP]: ModelPropToSnapshot<MP[k]> extends infer R ? R : never;
}>;
export type ModelPropsToUntransformedCreationData<MP extends ModelProps> = {
    [k in keyof MP]?: ModelPropStoredCreationValue<MP[k]>;
} & {
    [k in RequiredModelProps<MP>]: ModelPropStoredCreationValue<MP[k]>;
};
export type ModelPropsToSnapshotCreationData<MP extends ModelProps> = Flatten<{
    [k in keyof MP]?: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never;
} & {
    [k in {
        [K in keyof MP]: IsNeverType<ModelPropFromSnapshotOverride<MP[K]>, MP[K]["$isRequired"] & K, // no override
        IsOptionalValue<ModelPropFromSnapshotOverride<MP[K]>, never, K>>;
    }[keyof MP]]: ModelPropFromSnapshot<MP[k]> extends infer R ? R : never;
}>;
export type ModelPropsToTransformedData<MP extends ModelProps> = Flatten<{
    [k in keyof MP]: MP[k]["$transformedValueType"];
}>;
export type ModelPropsToTransformedCreationData<MP extends ModelProps> = {
    [k in keyof MP]?: MP[k]["$transformedCreationValueType"];
} & {
    [k in RequiredModelProps<MP>]: MP[k]["$transformedCreationValueType"];
};
export type ModelPropsToSetter<MP extends ModelProps> = Flatten<{
    [k in keyof MP as MP[k]["$hasSetter"] & `set${Capitalize<k & string>}`]: (value: MP[k]["$transformedValueType"]) => void;
}>;
export type ModelIdProp<T extends string = string> = ModelProp<T, T | undefined, T, T | undefined, never, // not required
true>;
type TypedModelIdProp<T extends string = string, THasSetter = never> = Omit<ModelProp<T, T | undefined, T, T | undefined, never, true, THasSetter>, "withSetter"> & {
    /**
     * Enables generation of a setter method for the ID prop (`setId` for `id`, `setCustomId` for `customId`).
     */
    withSetter(): TypedModelIdProp<T, string>;
    /**
     * Enables generation of a setter method for the ID prop and applies a value transform to setter input.
     */
    withSetter(valueTransform: ModelPropSetterValueTransform<T>): TypedModelIdProp<T, string>;
    /**
     * @deprecated Setter methods are preferred.
     */
    withSetter(mode: "assign"): TypedModelIdProp<T, string>;
    /**
     * Sets a custom generator for missing model IDs in this `idProp`.
     */
    withGenerator(generator: () => T): TypedModelIdProp<T, THasSetter>;
    /**
     * Same as `idProp`, except that it might have a specific TypeScript string template as type.
     * E.g. `idProp.typedAs<`custom-${string}`>()`
     */
    typedAs<U extends string>(): TypedModelIdProp<U, THasSetter>;
};
/**
 * A property that will be used as model id, accessible through $modelId.
 * Can only be used in models and there can be only one per model.
 */
export declare const idProp: TypedModelIdProp;
/**
 * @ignore
 */
export type OnlyPrimitives<T> = Exclude<T, object>;
/**
 * A model prop that maybe / maybe not is optional, depending on if the value can take undefined.
 */
export type MaybeOptionalModelProp<TPropValue> = ModelProp<TPropValue, TPropValue, TPropValue, TPropValue, IsOptionalValue<TPropValue, never, string>>;
/**
 * A model prop that is definitely optional.
 */
export type OptionalModelProp<TPropValue> = ModelProp<TPropValue, TPropValue | null | undefined, TPropValue, TPropValue | null | undefined, never>;
/**
 * Defines a model property, with an optional function to generate a default value
 * if the input snapshot / model creation data is `null` or `undefined`.
 *
 * Example:
 * ```ts
 * x: prop(() => 10) // an optional number, with a default value of 10
 * x: prop<number[]>(() => []) // an optional number array, with a default empty array
 * ```
 *
 * @template TValue Value type.
 * @param defaultFn Default value generator function.
 * @returns
 */
export declare function prop<TValue>(defaultFn: () => TValue): OptionalModelProp<TValue>;
/**
 * Defines a model property, with an optional default value
 * if the input snapshot / model creation data is `null` or `undefined`.
 * You should only use this with primitive values and never with object values
 * (array, model, object, etc).
 *
 * Example:
 * ```ts
 * x: prop(10) // an optional number, with a default value of 10
 * ```
 *
 * @template TValue Value type.
 * @param defaultValue Default primitive value.
 * @returns
 */
export declare function prop<TValue>(defaultValue: OnlyPrimitives<TValue>): OptionalModelProp<TValue>;
/**
 * Defines a model property with no default value.
 *
 * Example:
 * ```ts
 * x: prop<number>() // a required number
 * x: prop<number | undefined>() // an optional number, which defaults to undefined
 * ```
 *
 * @template TValue Value type.
 * @returns
 */
export declare function prop<TValue>(): MaybeOptionalModelProp<TValue>;
/**
 * @ignore
 */
export declare function getModelPropDefaultValue(propData: AnyModelProp): unknown | typeof noDefaultValue;
/**
 * @ignore
 */
export declare function getModelPropStoredDefaultValue(propData: AnyModelProp, model: object, propName: string): unknown | typeof noDefaultValue;
export {};