import { computed, signal } from "alien-signals";

//#region src/core.d.ts
type MaybeReactive<T> = T | Reactive<T>;
declare class Reactive<T> {
  protected source: ReturnType<typeof signal<T>> | ReturnType<typeof computed<T>>;
  constructor(source: ReturnType<typeof signal<T>> | ReturnType<typeof computed<T>>);
  get(): T;
  peek(): T;
  trigger(): void;
}
declare class Signal<T> extends Reactive<T> {
  private readonlyComputed;
  /**
   * Create a new mutable signal.
   *
   * @param initialValue - Initial value stored in the signal.
   */
  constructor(initialValue: T);
  /**
   * Update the stored value and notify subscribers.
   *
   * @param value - Next value to store in the signal.
   */
  set(value: T): void;
  readonly(): Computed<T>;
}
declare class Computed<T> extends Reactive<T> {
  /**
   * Create a read-only derived signal.
   *
   * @param getter - Function that derives the value from dependencies.
   */
  constructor(getter: (previousValue?: T) => T);
}
/**
 * Factory that creates a mutable `Signal` instance.
 *
 * @param initialValue - Initial value stored in the signal.
 */
declare function signal$1<T>(initialValue: T): Signal<T>;
/**
 * Type guard that checks whether an object is a `Signal` instance.
 */
declare function isSignal<T = any>(obj: unknown): obj is Signal<T>;
/**
 * Factory that creates a read-only `Computed` instance.
 *
 * @param getter - Function that derives the value from dependencies.
 */
declare function computed$1<T>(getter: (previousValue?: T) => T): Computed<T>;
/**
 * Type guard that checks whether an object is a `Computed` instance.
 */
declare function isComputed<T = any>(obj: unknown): obj is Computed<T>;
/**
 * Type guard that checks whether an object is a `Signal` or a `Computed` instance.
 */
declare function isReactive<T = any>(obj: unknown): obj is Reactive<T>;
/**
 * Execute a function inside a `alien-signals` batch to group updates.
 *
 * @param fn - Function whose updates should be batched.
 * @return The value returned by the function.
 */
declare function batch<T>(fn: () => T): T;
/**
 * Temporarily clears the active subscriber while running `fn`, so reads
 * performed inside the callback do not become dependencies of the currently
 * active subscriber. Effects created inside the callback are not parented to
 * the active subscriber.
 *
 * @param fn Callback function to run.
 * @returns Value returned by the callback.
 */
declare function untracked<T>(fn: () => T): T;
/**
 * Returns a promise that resolves when two values become strictly equal.
 *
 * The values are compared using `unwrap` and strict equality (`===`).
 *
 * @param a First value to compare.
 * @param b Second value to compare.
 *
 * @returns A promise that resolves when both values become strictly equal.
 *
 * @throws {CannotBecomeEqualError} If both values are non-reactive and different,
 * as they can never become equal.
 */
declare function whenEqual<T>(a: MaybeReactive<T>, b: MaybeReactive<T>): Promise<void>;
declare class CannotBecomeEqualError extends Error {
  constructor();
}
/**
 * Returns a promise that resolves when the given condition becomes true.
 *
 * The condition run inside an effect, so it will re-evaluate
 * whenever a reactive dependencies used inside it change.
 *
 * @param condition A function returning a boolean condition.
 *
 * @returns A promise that resolves when `condition()` returns `true`.
 * The promise may never resolve if the condition never becomes true.
 */
declare function when(condition: () => boolean): Promise<void>;
/**
 * Returns the underlying value of a `Reactive` instance,
 * or the value itself if it is not reactive.
 */
declare function unwrap<T>(value: T | Reactive<T>): T;
//#endregion
export { CannotBecomeEqualError, Computed, MaybeReactive, Reactive, Signal, batch, computed$1 as computed, isComputed, isReactive, isSignal, signal$1 as signal, untracked, unwrap, when, whenEqual };