import { EffectScope, DebuggerOptions, WatchCallback, WatchOptions as WatchOptions$1 } from '@vue/reactivity';
export { OnCleanup, WatchCallback, WatchHandle, WatchSource, WatchStopHandle } from '@vue/reactivity';

type ClassGetterDecorator<This = any, Value = any> = (value: (this: This) => Value, context: ClassGetterDecoratorContext) => ((this: This) => Value) | void;
type ClassMethodDecorator<This = any, Value extends (...p: any[]) => any = any> = (value: Value, context: ClassMethodDecoratorContext<This, Value>) => Value | void;
type ClassFieldDecorator<This = any, Value extends (...p: any[]) => any = any> = (value: Value, context: ClassFieldDecoratorContext<This, Value>) => Value | void;

interface ReactiveDecorator {
    decoratorType: string;
    decorate2023?: (value: any, context: DecoratorContext) => void;
    decorate2021?: (value: any, propertyKey: string | symbol) => void;
    make: (target: any, key: PropertyKey, descriptor: PropertyDescriptor) => any;
    options?: any;
}
declare function isReactiveDecorator(thing: any): thing is ReactiveDecorator;
declare function is2023Decorator(): boolean;

declare const STORED_ADM_KEY: unique symbol;
declare class ObservableObjectAdministration {
    target: any;
    records: Record<PropertyKey, {
        raw: any;
        decorator: ReactiveDecorator;
    }>;
    constructor(target: any);
    getRecord(key: PropertyKey): {
        raw: any;
        decorator: ReactiveDecorator;
    };
    setRecord(key: PropertyKey, value: any, decorator: ReactiveDecorator): void;
    make(key: PropertyKey, decorator: ReactiveDecorator): void;
}
interface IIsObservableObject {
    [STORED_ADM_KEY]: ObservableObjectAdministration;
}

declare const isComputed: {
    (decorator: ReactiveDecorator): boolean;
    <T extends object>(target: T, key: keyof T): boolean;
};
declare const Computed: PropertyDecorator & ReactiveDecorator & ClassGetterDecorator;

declare function getEffectScope(target: any): EffectScope;

declare function makeObservable<T extends object>(target: T): T;

interface IObservableFactory extends ReactiveDecorator, PropertyDecorator, ClassFieldDecorator {
    ref: ReactiveDecorator & PropertyDecorator & ClassFieldDecorator;
    shallowRef: ReactiveDecorator & PropertyDecorator & ClassFieldDecorator;
    reactive: ReactiveDecorator & PropertyDecorator & ClassFieldDecorator;
    shallowReactive: ReactiveDecorator & PropertyDecorator & ClassFieldDecorator;
}
declare const Observable: IObservableFactory;
declare const isObservable: {
    (decorator: ReactiveDecorator): boolean;
    <T extends object>(target: T, key: keyof T): boolean;
};

interface WatchEffectOptions extends DebuggerOptions {
    flush?: 'pre' | 'post' | 'sync';
}
interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
    immediate?: Immediate;
    deep?: boolean | number;
    once?: boolean;
}

declare function nextTick<T = void, R = void>(this: T, fn?: (this: T) => R): Promise<Awaited<R>>;

declare const isWatch: {
    (decorator: ReactiveDecorator): boolean;
    <T extends object>(target: T, key: keyof T): boolean;
};
declare function Watch<TTarget extends object, TKey extends keyof TTarget, TValue = TTarget[TKey], TCallback extends WatchCallback<TValue> = WatchCallback<TValue>>(source: TKey, options?: WatchOptions$1): ClassMethodDecorator<TTarget, TCallback>;
declare function Watch<TTarget extends object, TValue, TCallback extends WatchCallback<TValue> = WatchCallback<TValue>>(source: ((this: TTarget) => TValue), options?: WatchOptions$1): ClassMethodDecorator<TTarget, TCallback>;

declare const WatchEffect: PropertyDecorator & ReactiveDecorator & ClassMethodDecorator;
declare const WatchSyncEffect: PropertyDecorator & ReactiveDecorator & ClassMethodDecorator;
declare const isWatchEffect: {
    (decorator: ReactiveDecorator): boolean;
    <T extends object>(target: T, key: keyof T): boolean;
};

export { Computed, type IIsObservableObject, type IObservableFactory, Observable, type ReactiveDecorator, Watch, WatchEffect, type WatchOptions, WatchSyncEffect, getEffectScope, is2023Decorator, isComputed, isObservable, isReactiveDecorator, isWatch, isWatchEffect, makeObservable, nextTick };