/**
 * @template [T = unknown]
 * @extends { ModelImpl<T> }
 */
export class ModelWrapperImpl<T = unknown> extends ModelImpl<T, boolean, boolean, import("../../reactivity/common.types").NormalizeRef<import("../../reactivity/common.types").UnwrapRefOrGetter<T>, boolean> | (T extends Ref<any, any> ? T : import("../../reactivity/common.types").NormalizeRef<import("../../reactivity/common.types").UnwrapRefOrGetter<T>, boolean>)> {
    /**
     * @this { ModelWrapperImpl<unknown> }
     * @param { UnknownModel | ModelWrapperImpl } model
     * @param { ModelWrapperImplOptions } [options]
     */
    constructor(this: ModelWrapperImpl<unknown>, model: UnknownModel | ModelWrapperImpl, options?: ModelWrapperImplOptions);
    /**
     * @template { Function } F
     * @overload
     * @param { F } value
     * @param { unknown } [thisArg]
     * @param { unknown[] } [args]
     * @returns { ReturnType<F> }
     */
    update<F extends Function>(value: F, thisArg?: unknown, args?: unknown[] | undefined): ReturnType<F>;
    /**
     * @overload
     * @param { unknown } value
     * @returns { void }
     */
    update(value: unknown): void;
    /**
     * @template { Function } F
     * @overload
     * @param { F } fn
     * @returns { F }
     */
    updateDecorator<F extends Function>(fn: F): F;
    /**
     * @template { boolean } [Immediate = false]
     * @overload
     * @param { ExternalModelUpdateCallback<T, Immediate> } callback
     * @param { Omit<WatchOptions<Immediate>, 'deep'> & { onMounted?: boolean } } [options]
     * @returns { () => void }
     */
    onExternalUpdate<Immediate extends boolean = false>(callback: ExternalModelUpdateCallback<T, Immediate>, options?: (Omit<WatchOptions<Immediate>, "deep"> & {
        onMounted?: boolean;
    }) | undefined): () => void;
    /**
     * @template { boolean } [Immediate = false]
     * @overload
     * @param { WatchCallback<T, MaybeUndefined<T, Immediate>> } callback
     * @param { Omit<WatchOptions<Immediate>, 'deep'> } [options]
     * @returns { () => void }
     */
    onInternalUpdate<Immediate extends boolean = false>(callback: WatchCallback<T, MaybeUndefined<T, Immediate>>, options?: Omit<WatchOptions<Immediate>, "deep"> | undefined): () => void;
    handleValidation(eager?: boolean): void;
    /**
     * @param { number } minWait
     * @param {{ eager?: boolean }} [options]
     * @returns { (eager?: boolean) => void }
     */
    useDebouncedValidation(minWait: number, options?: {
        eager?: boolean;
    }): (eager?: boolean) => void;
    triggerIfShallow(): void;
    #private;
}
export type ModelWrapperImplOptions = {
    exposed?: Readonly<Record<string, any>> | undefined;
    elements?: Readonly<Record<string, HTMLElement | null>> | undefined;
    maybeObject?: boolean | undefined;
};
import type { Ref } from "vue";
import { ModelImpl } from "#composables/.private/ModelImpl";
import type { ExternalModelUpdateCallback } from "#composables";
import type { WatchOptions } from "vue";
import type { MaybeUndefined } from "#utilities";
import type { WatchCallback } from "vue";
import type { UnknownModel } from "#composables";
//# sourceMappingURL=ModelWrapperImpl.d.ts.map