/**
 * Reactive Signal System
 *
 * Core reactivity implementation using signals pattern.
 * Signals are reactive primitives that automatically track dependencies
 * and notify subscribers when values change.
 *
 * Features:
 * - Fine-grained reactivity
 * - Automatic dependency tracking
 * - Batched updates
 * - Effect cleanup
 * - Computed signals (lazy & cached)
 *
 * @example Basic usage
 * ```javascript
 * const count = Gyos.signal(0);
 *
 * Gyos.effect(() => {
 *   console.log('Count:', count.value); // Auto re-runs when count changes
 * });
 *
 * count.value++; // Triggers effect
 * ```
 */
import type { Signal, Computed, SignalOptions } from '../types';
/**
 * Create a reactive signal
 *
 * Signals are reactive primitives that track dependencies automatically.
 * When a signal's value changes, all dependent effects are re-run.
 *
 * @param initialValue - Initial value of the signal
 * @param debugOrOptions - Optional debug label or options (debugLabel, equals comparator)
 * @returns Signal object with reactive value getter/setter
 *
 * @example
 * ```javascript
 * const count = Gyos.signal(0);
 * const labeled = Gyos.signal(0, 'counter');
 * const customEq = Gyos.signal({ x: 1 }, { equals: (a,b) => a.x === b.x, debugLabel: 'point' });
 *
 * // Read value (tracks dependency if inside effect)
 * console.log(count.value); // 0
 * console.log(count());     // 0 (shorthand, same as .value)
 *
 * // Write value (notifies subscribers)
 * count.value = 1;
 * count(2);                // Shorthand setter
 *
 * // Peek without tracking
 * console.log(count.peek); // 2
 *
 * // Update with function
 * count.update(n => n + 1);
 *
 * // Subscribe to changes
 * const unsubscribe = count.subscribe(() => {
 *   console.log('Changed:', count.value);
 * });
 * ```
 */
export declare function signal<T>(initialValue: T, debugOrOptions?: string | SignalOptions<T>): Signal<T>;
/**
 * Create a computed signal (derived/memoized value)
 *
 * Computed signals automatically re-compute when their dependencies change.
 * The computation is lazy (only runs when value is read) and cached.
 *
 * @param fn - Computation function (should be pure)
 * @returns Computed signal (read-only)
 *
 * @example
 * ```javascript
 * const count = Gyos.signal(5);
 * const doubled = Gyos.computed(() => count.value * 2);
 *
 * console.log(doubled.value); // 10
 * console.log(doubled());     // 10 (callable shorthand)
 *
 * count.value = 10;
 * console.log(doubled.value); // 20 (auto-updated)
 * console.log(doubled());     // 20 (callable)
 * ```
 *
 * @example With multiple dependencies
 * ```javascript
 * const firstName = Gyos.signal('John');
 * const lastName = Gyos.signal('Doe');
 * const fullName = Gyos.computed(() => `${firstName.value} ${lastName.value}`);
 *
 * console.log(fullName());    // "John Doe"
 * ```
 */
export declare function computed<T>(fn: () => T): Computed<T>;
/**
 * Create an effect (side effect that runs when dependencies change)
 *
 * Effects are functions that run immediately and re-run whenever their
 * reactive dependencies change. Used for side effects like DOM updates,
 * logging, or API calls.
 *
 * @param fn - Effect function (can return cleanup function)
 * @returns Cleanup function to stop the effect
 *
 * @example Basic effect
 * ```javascript
 * const count = Gyos.signal(0);
 *
 * const stop = Gyos.effect(() => {
 *   console.log('Count is:', count.value);
 * });
 *
 * count.value = 1; // Logs: "Count is: 1"
 * stop(); // Stop watching
 * ```
 *
 * @example Effect with cleanup
 * ```javascript
 * const id = Gyos.signal(1);
 *
 * Gyos.effect(() => {
 *   const controller = new AbortController();
 *
 *   fetch(`/api/user/${id.value}`, { signal: controller.signal })
 *     .then(res => res.json())
 *     .then(data => console.log(data));
 *
 *   // Cleanup: abort fetch when id changes
 *   return () => controller.abort();
 * });
 * ```
 */
export declare function effect(fn: () => void | (() => void)): () => void;
/**
 * Batch multiple updates into a single render
 *
 * Prevents multiple re-renders when updating multiple signals.
 * All effects are collected and run once after the batch completes.
 *
 * @param fn - Function containing multiple signal updates
 *
 * @example Without batch (3 renders)
 * ```javascript
 * const a = Gyos.signal(1);
 * const b = Gyos.signal(2);
 * const c = Gyos.signal(3);
 *
 * Gyos.effect(() => {
 *   console.log('Sum:', a.value + b.value + c.value);
 * });
 *
 * a.value = 10; // Render 1
 * b.value = 20; // Render 2
 * c.value = 30; // Render 3
 * ```
 *
 * @example With batch (1 render)
 * ```javascript
 * Gyos.batch(() => {
 *   a.value = 10;
 *   b.value = 20;
 *   c.value = 30;
 * }); // Single render with all values updated
 * ```
 */
export declare function batch(fn: () => void): void;
/**
 * Check if a value is a signal
 *
 * @param value - Value to check
 * @returns True if value is a signal
 *
 * @example
 * ```javascript
 * const sig = Gyos.signal(5);
 * const num = 10;
 *
 * Gyos.isSignal(sig); // true
 * Gyos.isSignal(num); // false
 * ```
 */
export declare function isSignal(value: any): value is Signal;
export declare function hasCurrentEffect(): boolean;
/**
 * Check if a value is a computed
 *
 * @param value - Value to check
 * @returns True if value is a computed
 *
 * @example
 * ```javascript
 * const comp = Gyos.computed(() => 5 + 5);
 * const num = 10;
 *
 * Gyos.isComputed(comp); // true
 * Gyos.isComputed(num); // false
 * ```
 */
export declare function isComputed(value: any): value is Computed;
/**
 * Unwrap signal value (or return value as-is)
 *
 * Useful when you don't know if a value is a signal or plain value.
 *
 * @param value - Signal or plain value
 * @returns Unwrapped value
 *
 * @example
 * ```javascript
 * const sig = Gyos.signal(5);
 * const num = 10;
 *
 * Gyos.unref(sig); // 5
 * Gyos.unref(num); // 10
 * ```
 */
export declare function unref<T>(value: T | Signal<T>): T;
/**
 * Run a function without collecting reactive dependencies
 * Useful to avoid accidental subscriptions during setup or non-reactive reads.
 */
export declare function untrack<T>(fn: () => T): T;
//# sourceMappingURL=signal.d.ts.map