import {
  routeActive,
  TimerOptions,
  WatchSource,
  WatchCallback,
  on,
  ActivityPredicate,
  ListenerTarget,
  capture,
  WatchValues,
  documentVisible,
  task,
  watch,
  WatchContext,
  windowFocused,
  timer,
} from '../core.js';
/** Reactive result of a {@link resource}: current value, loading state, and controls. */
interface ResourceResult<T> {
  value: T | null;
  pending: boolean;
  error: Error | null;
  refresh(): void;
}
/** Create a source-driven resource whose loader receives the latest source value. */
declare function resource<TSource, T>(
  source: () => TSource,
  load: (value: TSource, opts: { signal: AbortSignal }) => PromiseLike<T> | T
): ResourceResult<T>;
/** Creates a render-scoped async resource with cancellation and refresh; SSR has special data rules. */
declare function resource<
  T,
  const TDeps extends readonly unknown[] = readonly unknown[],
>(
  fn: (opts: { signal: AbortSignal }) => PromiseLike<T> | T,
  deps: TDeps
): ResourceResult<T>;
declare function resource<T>(
  fn: (opts: { signal: AbortSignal }) => PromiseLike<T> | T
): ResourceResult<T>;
/** Connection status of a {@link stream}. */
type StreamStatus =
  | 'connecting'
  | 'connected'
  | 'reconnecting'
  | 'closed'
  | 'error';
/** Reactive result of a {@link stream}: current value, connection status, and controls. */
interface StreamResult<T> {
  value: T | null;
  status: StreamStatus;
  pending: boolean;
  stale: boolean;
  error: Error | null;
  restart(): void;
  close(): void;
}
/** Options for {@link stream}. */
interface StreamOptions<T> {
  deps?: readonly unknown[];
  initialValue?: T;
}
type StreamSource<T> = (context: {
  signal: AbortSignal;
}) => AsyncIterable<T> | PromiseLike<AsyncIterable<T>>;
/** Connect a stream from an input read during a positional component render. */
declare function stream<TSource, T>(
  source: () => TSource,
  connect: (
    value: TSource,
    context: { signal: AbortSignal }
  ) => AsyncIterable<T> | PromiseLike<AsyncIterable<T>>,
  options?: Omit<StreamOptions<T>, 'deps'>
): StreamResult<T>;
/** Subscribe to a streaming data source for the current component's lifetime, with auto reconnect/cleanup. */
declare function stream<T>(
  source: StreamSource<T>,
  options?: StreamOptions<T>
): StreamResult<T>;
export {
  type ActivityPredicate,
  type ListenerTarget,
  type ResourceResult,
  type StreamOptions,
  type StreamResult,
  type StreamStatus,
  type TimerOptions,
  type WatchCallback,
  type WatchContext,
  type WatchSource,
  type WatchValues,
  capture,
  documentVisible,
  on,
  resource,
  routeActive,
  stream,
  task,
  timer,
  watch,
  windowFocused,
};