import type { Alpine as AlpineType } from 'alpinejs';
import type { toRaw as _toRaw, stop as _stop } from 'vue';
declare const _refBrand: unique symbol;
declare global {
    var _alpineReactivity: {
        Alpine: AlpineType | null;
    };
}
export declare const setAlpine: (instance: AlpineType) => void;
export declare const getAlpine: () => AlpineType;
export interface Ref<T = any> {
    readonly [_refBrand]: true;
    value: T;
}
export type MaybeRef<T> = T | Ref<T>;
export interface ComputedRef<T = any> extends Ref<T> {
    /** `effect` is added to be able to differentiate refs from computed properties. */
    effect: true;
    readonly value: T;
}
export type ToRefs<T extends object> = {
    [K in keyof T]: Ref<UnwrapRef<T[K]>>;
};
export declare const computed: <T = any>(cb: () => T) => ComputedRef<T>;
export declare const reactive: <T = any>(val: T) => T;
export declare const ref: <T = any>(value?: T | undefined) => T extends Ref<any> ? T : Ref<T>;
export declare const writableComputed: <T = any>(options: {
    get: () => T;
    set: (newVal: T) => void;
}) => Ref<T>;
export declare function isRef<T>(value: any): value is Ref<T>;
export declare const isComputed: <T = any>(value: any) => value is ComputedRef<T>;
export declare function unref<T>(ref: T | Ref<T>): T;
export declare const shallowRef: <T = any>(initialValue?: T | undefined) => Ref<T>;
export declare const toRef: <T extends object, K extends keyof T>(object: T, key: K) => Ref<T[K]>;
export declare const toRefs: <T extends object>(object: T) => ToRefs<T>;
export declare const toRaw: typeof _toRaw;
export declare const stop: typeof _stop;
export type UnwrapRef<T> = T extends Ref<infer V> ? UnwrapRefSimple<V> : T extends ComputedRef<infer V> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
export type UnwrapRefSimple<T> = T extends Ref ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? {
    [K in keyof T]: UnwrapRefSimple<T[K]>;
} : T;
/**
 * @example
 *
 * const state = readonly({
 *   count: 1,
 *   nested: {
 *     value: 10,
 *   },
 * });
 *
 * console.log(state.count); // Output: 1
 * state.count = 2;          // Warning: Cannot set property count on a readonly object
 * console.log(state.count); // Output: 1
 * delete state.count;       // Warning: Cannot delete property count on a readonly object
 *
 * console.log(state.nested.value); // Output: 10
 * state.nested.value = 20;         // Warning: Cannot set property value on a readonly object
 * console.log(state.nested.value); // Output: 10
 */
export declare const readonly: <T>(target: T) => any;
type Primitive = string | number | boolean | bigint | symbol | undefined | null;
type Builtin = Primitive | Function | Date | Error | RegExp;
export type DeepReadonly<T> = T extends Builtin ? T : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends WeakMap<infer K, infer V> ? WeakMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends WeakSet<infer U> ? WeakSet<DeepReadonly<U>> : T extends Promise<infer U> ? Promise<DeepReadonly<U>> : T extends Ref<infer U> ? Readonly<Ref<DeepReadonly<U>>> : T extends {} ? {
    readonly [K in keyof T]: DeepReadonly<T[K]>;
} : Readonly<T>;
export type WatchEffect = () => void;
export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T);
export type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV) => any;
export type WatchStopHandle = () => void;
type MapSources<T> = {
    [K in keyof T]: T[K] extends WatchSource<infer V> ? V : T[K] extends object ? T[K] : never;
};
type MapOldSources<T, Immediate> = {
    [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : T[K] extends object ? Immediate extends true ? T[K] | undefined : T[K] : never;
};
export interface WatchOptions<Immediate = boolean> {
    immediate?: Immediate;
    deep?: boolean;
    flush?: 'pre' | 'sync' | 'post';
}
export declare function watchEffect(effect: () => unknown): WatchStopHandle;
export declare function watch<T extends Readonly<WatchSource<unknown>[]>, Immediate extends Readonly<boolean> = false>(sources: T, cb: WatchCallback<MapSources<T>, MapOldSources<T, Immediate>>, options?: WatchOptions<Immediate>): WatchStopHandle;
export declare function watch<T, Immediate extends Readonly<boolean> = false>(source: WatchSource<T>, cb: WatchCallback<T, Immediate extends true ? T | undefined : T>, options?: WatchOptions<Immediate>): WatchStopHandle;
export {};