export declare const RegistryContext: React.Context<Registry.Registry>

export declare const useRx: <R, W>(
  rx: Rx.Writable<R, W>
) => readonly [value: R, setOrUpdate: (_: W | ((_: R) => W)) => void]

export declare const useRxInitialValues: (initialValues: Iterable<readonly [Rx.Rx<any>, any]>) => void

export declare const useRxMount: <A>(rx: Rx.Rx<A>) => void

export declare const useRxRef: <A>(ref: RxRef.ReadonlyRef<A>) => A

export declare const useRxRefProp: <A, K extends keyof A>(ref: RxRef.RxRef<A>, prop: K) => RxRef.RxRef<A[K]>

export declare const useRxRefPropValue: <A, K extends keyof A>(ref: RxRef.RxRef<A>, prop: K) => A[K]

export declare const useRxRefresh: <A>(rx: Rx.Rx<A> & Rx.Refreshable) => () => void

export declare const useRxSet: <R, W>(rx: Rx.Writable<R, W>) => (_: W | ((_: R) => W)) => void

export declare const useRxSetPromise: <E, A, W>(
  rx: Rx.Writable<Result.Result<A, E>, W>
) => (_: W) => Promise<Exit.Exit<A, E>>

export declare const useRxSubscribe: <A>(
  rx: Rx.Rx<A>,
  f: (_: A) => void,
  options?: { readonly immediate?: boolean }
) => void

export declare const useRxSuspense: <A, E>(
  rx: Rx.Rx<Result.Result<A, E>>,
  options?: { readonly suspendOnWaiting?: boolean }
) => Result.Success<A, E> | Result.Failure<A, E>

export declare const useRxSuspenseSuccess: <A, E>(
  rx: Rx.Rx<Result.Result<A, E>>,
  options?: { readonly suspendOnWaiting?: boolean }
) => Result.Success<A, E>

export declare const useRxValue: { <A>(rx: Rx.Rx<A>): A; <A, B>(rx: Rx.Rx<A>, f: (_: A) => B): B }

export * as Registry from "@effect-rx/rx/Registry"

export * as Result from "@effect-rx/rx/Result"

export * as Rx from "@effect-rx/rx/Rx"

export * as RxRef from "@effect-rx/rx/RxRef"