export * from 'alien-signals';

type Signal<T = any> = {
    (): T;
    (value: T): void;
};
type Computed<T = any> = () => T;
declare const batch: <T>(fn: () => T) => T;

declare const isDeepSignal: (source: any) => boolean;
declare const isShallow: (source: any) => boolean;
declare const deepSignal: <T extends object>(obj: T) => DeepSignal<T>;
declare const peek: <T extends DeepSignalObject<object>, K extends keyof RevertDeepSignalObject<T>>(obj: T, key: K) => RevertDeepSignal<RevertDeepSignalObject<T>[K]>;
declare const shallowFlag: unique symbol;
declare function shallow<T extends object>(obj: T): Shallow<T>;
declare const rawFlag: unique symbol;
declare function markRaw<T extends object>(obj: T): Raw<T>;
declare const raw: typeof markRaw;
/** TYPES **/
type DeepSignal<T> = T extends Function ? T : T extends {
    [shallowFlag]: true;
} ? T : T extends {
    [rawFlag]: true;
} ? T : T extends Array<unknown> ? DeepSignalArray<T> : T extends object ? DeepSignalObject<T> : T;
type DeepSignalObject<T extends object> = {
    [P in keyof T & string as `$${P}`]?: T[P] extends Function ? never : Signal<T[P]>;
} & {
    [P in keyof T]: DeepSignal<T[P]>;
};
/** @ts-expect-error **/
interface DeepArray<T> extends Array<T> {
    map: <U>(callbackfn: (value: DeepSignal<T>, index: number, array: DeepSignalArray<T[]>) => U, thisArg?: any) => U[];
    forEach: (callbackfn: (value: DeepSignal<T>, index: number, array: DeepSignalArray<T[]>) => void, thisArg?: any) => void;
    concat(...items: ConcatArray<T>[]): DeepSignalArray<T[]>;
    concat(...items: (T | ConcatArray<T>)[]): DeepSignalArray<T[]>;
    reverse(): DeepSignalArray<T[]>;
    shift(): DeepSignal<T> | undefined;
    slice(start?: number, end?: number): DeepSignalArray<T[]>;
    splice(start: number, deleteCount?: number): DeepSignalArray<T[]>;
    splice(start: number, deleteCount: number, ...items: T[]): DeepSignalArray<T[]>;
    filter(predicate: (value: DeepSignal<T>, index: number, array: DeepSignalArray<T[]>) => unknown, thisArg?: any): DeepSignalArray<T[]>;
    reduce(callbackfn: (previousValue: DeepSignal<T>, currentValue: DeepSignal<T>, currentIndex: number, array: DeepSignalArray<T[]>) => T): DeepSignal<T>;
    reduce(callbackfn: (previousValue: DeepSignal<T>, currentValue: DeepSignal<T>, currentIndex: number, array: DeepSignalArray<T[]>) => DeepSignal<T>, initialValue: T): DeepSignal<T>;
    reduce<U>(callbackfn: (previousValue: U, currentValue: DeepSignal<T>, currentIndex: number, array: DeepSignalArray<T[]>) => U, initialValue: U): U;
    reduceRight(callbackfn: (previousValue: DeepSignal<T>, currentValue: DeepSignal<T>, currentIndex: number, array: DeepSignalArray<T[]>) => T): DeepSignal<T>;
    reduceRight(callbackfn: (previousValue: DeepSignal<T>, currentValue: DeepSignal<T>, currentIndex: number, array: DeepSignalArray<T[]>) => DeepSignal<T>, initialValue: T): DeepSignal<T>;
    reduceRight<U>(callbackfn: (previousValue: U, currentValue: DeepSignal<T>, currentIndex: number, array: DeepSignalArray<T[]>) => U, initialValue: U): U;
}
type ArrayType<T> = T extends Array<infer I> ? I : T;
type DeepSignalArray<T> = DeepArray<ArrayType<T>> & {
    [key: number]: DeepSignal<ArrayType<T>>;
    $?: {
        [key: number]: Signal<ArrayType<T>>;
    };
    $length?: Signal<number>;
};
type Shallow<T extends object> = T & {
    [shallowFlag]: true;
};
type Raw<T extends object> = T & {
    [rawFlag]: true;
};
declare const useDeepSignal: <T extends object>(obj: T) => DeepSignal<T>;
type FilterSignals<K> = K extends `$${infer P}` ? never : K;
type RevertDeepSignalObject<T> = Pick<T, FilterSignals<keyof T>>;
type RevertDeepSignalArray<T> = Omit<T, '$' | '$length'>;
type RevertDeepSignal<T> = T extends Array<unknown> ? RevertDeepSignalArray<T> : T extends object ? RevertDeepSignalObject<T> : T;

type OnCleanup = (cleanupFn: () => void) => void;
type WatchEffect = (onCleanup: OnCleanup) => void;
type WatchSource<T = any> = Signal<T> | Computed<T> | (() => T);
type WatchFlush = 'pre' | 'post' | 'sync';
interface WatchOptions<Immediate = boolean> {
    immediate?: Immediate;
    deep?: boolean | number;
    once?: boolean;
    flush?: WatchFlush;
    scheduler?: (job: () => void, isFirstRun: boolean) => void;
}
type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
interface WatchHandle {
    (): void;
    pause: () => void;
    resume: () => void;
    stop: () => void;
}
declare function watch(source: WatchSource | WatchSource[] | WatchEffect | object, cb?: WatchCallback, options?: WatchOptions): WatchHandle;
declare function traverse(value: unknown, depth?: number, seen?: Set<unknown>): unknown;

declare function watchEffect(effect: WatchEffect): WatchHandle;

declare const isArray: typeof Array.isArray;
declare const isMap: (val: unknown) => val is Map<any, any>;
declare const isSet: (val: unknown) => val is Set<any>;
declare const isFunction: (val: unknown) => val is Function;
declare const isObject: (val: unknown) => val is Record<any, any>;
declare const isPlainObject: (val: unknown) => val is Record<PropertyKey, unknown>;
declare const isSignal: <T = any>(source: unknown) => source is Signal<T>;
declare const isComputed: <T = any>(source: unknown) => source is Computed<T>;
type MaybeSignal<T = any> = T | Signal<T>;
type MaybeSignalOrGetter<T = any> = MaybeSignal<T> | Computed<T> | (() => T);
declare function unSignal<T>(source: MaybeSignal<T> | Computed<T>): T;
declare function toValue<T>(source: MaybeSignalOrGetter<T>): T;
declare const peekSignal: <T>(source: Signal<T> | Computed<T>) => T;

export { type Computed, type DeepSignal, type MaybeSignal, type MaybeSignalOrGetter, type OnCleanup, type Raw, type RevertDeepSignal, type Shallow, type Signal, type WatchCallback, type WatchEffect, type WatchFlush, type WatchHandle, type WatchOptions, type WatchSource, batch, deepSignal, isArray, isComputed, isDeepSignal, isFunction, isMap, isObject, isPlainObject, isSet, isShallow, isSignal, markRaw, peek, peekSignal, raw, shallow, toValue, traverse, unSignal, useDeepSignal, watch, watchEffect };