/**
 * Perfect Reactivity - Utility Types
 *
 * Helper types for better TypeScript integration and DX.
 */
import type { IComputed } from "./computed";
import type { IEffect } from "./effect";
import type { ISignal } from "./signal";
/**
 * Extract the value type from a signal
 *
 * @example
 * ```ts
 * const count = signal(0);
 * type CountType = SignalValue<typeof count>; // number
 * ```
 */
export type SignalValue<S> = S extends ISignal<infer T> ? T : never;
/**
 * Extract the value type from a computed
 *
 * @example
 * ```ts
 * const double = computed(() => 42);
 * type DoubleType = ComputedValue<typeof double>; // number
 * ```
 */
export type ComputedValue<C> = C extends IComputed<infer T> ? T : never;
/**
 * Union type of all reactive primitives
 */
export type Reactive<T = any> = ISignal<T> | IComputed<T>;
/**
 * Type guard to check if value is a signal
 *
 * @example
 * ```ts
 * if (isSignal(value)) {
 *   value.write(42);
 * }
 * ```
 */
export declare function isSignal<T = any>(value: any): value is ISignal<T>;
/**
 * Type guard to check if value is a computed
 *
 * @example
 * ```ts
 * if (isComputed(value)) {
 *   const result = value.read();
 * }
 * ```
 */
export declare function isComputed<T = any>(value: any): value is IComputed<T>;
/**
 * Type guard to check if value is an effect
 *
 * @example
 * ```ts
 * if (isEffect(value)) {
 *   value.dispose();
 * }
 * ```
 */
export declare function isEffect(value: any): value is IEffect;
/**
 * Extract value from reactive or return as-is
 *
 * @example
 * ```ts
 * type T1 = Unwrap<ISignal<number>>; // number
 * type T2 = Unwrap<string>; // string
 * ```
 */
export type Unwrap<T> = T extends Reactive<infer U> ? U : T;
/**
 * Make all properties of an object reactive
 *
 * @example
 * ```ts
 * type User = { name: string; age: number };
 * type ReactiveUser = ReactiveObject<User>;
 * // { name: ISignal<string>; age: ISignal<number> }
 * ```
 */
export type ReactiveObject<T> = {
    [K in keyof T]: ISignal<T[K]>;
};
/**
 * Helper to create reactive object from plain object
 *
 * @example
 * ```ts
 * const user = reactiveObject({
 *   name: 'Alice',
 *   age: 25
 * });
 * user.name.write('Bob');
 * ```
 */
export declare function reactiveObject<T extends Record<string, any>>(obj: T): ReactiveObject<T>;
/**
 * Readonly signal - can only be read, not written
 *
 * @example
 * ```ts
 * function useCount() {
 *   const count = signal(0);
 *   const increment = () => count.write(count.read() + 1);
 *
 *   return {
 *     count: count as ReadonlySignal<number>,
 *     increment
 *   };
 * }
 * ```
 */
export type ReadonlySignal<T> = Omit<ISignal<T>, "write">;
/**
 * Readonly computed (already read-only by nature)
 */
export type ReadonlyComputed<T> = IComputed<T>;