export declare const get: <A>(self: ReadonlyReactiveRef<A>) => Effect.Effect<A>

export declare const modify: {
  <R, A>(f: (_: A) => readonly [returnValue: R, nextValue: A]): (self: ReactiveRef<A>) => Effect.Effect<R>
  <A, R>(self: ReactiveRef<A>, f: (_: A) => readonly [returnValue: R, nextValue: A]): Effect.Effect<R>
}

export declare const set: {
  <A>(value: A): (self: ReactiveRef<A>) => Effect.Effect<void>
  <A>(self: ReactiveRef<A>, value: A): Effect.Effect<void>
}

export declare const subscribe: <A>(self: ReadonlyReactiveRef<A>) => Effect.Effect<A, never, Reactive>

export declare const subscribeResult: <A, E>(
  self: ReactiveRef<Result.Result<A, E>>
) => Effect.Effect<Result.Success<A, E> | Result.Failure<A, E>, never, Reactive>

export declare const subscribeResultUnwrap: <A, E>(
  self: ReadonlyReactiveRef<Result.Result<A, E>>
) => Effect.Effect<A, E, Reactive>

export declare const unsafeGet: <A>(self: ReactiveRef<A>) => A

export declare const unsafeModify: {
  <R, A>(f: (_: A) => readonly [returnValue: R, nextValue: A]): (self: ReactiveRef<A>) => R
  <A, R>(self: ReactiveRef<A>, f: (_: A) => readonly [returnValue: R, nextValue: A]): R
}

export declare const unsafeSet: {
  <A>(value: A): (self: ReactiveRef<A>) => void
  <A>(self: ReactiveRef<A>, value: A): void
}

export declare const unsafeUpdate: {
  <A>(f: (_: A) => A): (self: ReactiveRef<A>) => void
  <A>(self: ReactiveRef<A>, f: (_: A) => A): void
}

export declare const update: {
  <A>(f: (_: A) => A): (self: ReactiveRef<A>) => Effect.Effect<void>
  <A>(self: ReactiveRef<A>, f: (_: A) => A): Effect.Effect<void>
}

export declare const make: <A>(value: A) => Effect.Effect<ReactiveRef<A>>

export declare const unsafeMake: <A>(value: A) => ReactiveRef<A>

export declare const fromEffect: <A, E, R>(
  effect: Effect.Effect<A, E, R>
) => Effect.Effect<ReadonlyReactiveRef<Result.Result<A, E>>, never, R | Scope.Scope>

export declare const fromStream: <A, E, R>(
  stream: Stream.Stream<A, E, R>
) => Effect.Effect<ReadonlyReactiveRef<Result.Result<A, E | Cause.NoSuchElementException>>, never, R | Scope.Scope>

export declare const fromStreamPull: <A, E, R>(
  stream: Stream.Stream<A, E, R>
) => Effect.Effect<
  { readonly ref: ReadonlyReactiveRef<PullResult<A, E>>; readonly pull: () => void },
  never,
  R | Scope.Scope
>

export declare const into: {
  <A, E>(
    self: ReactiveRef<Result.Result<A, E>>
  ): <R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R | Scope.Scope>
  <A, E, R>(
    self: ReactiveRef<Result.Result<A, E>>,
    effect: Effect.Effect<A, E, R>
  ): Effect.Effect<void, never, R | Scope.Scope>
}

export declare const intoStream: {
  <A, E>(
    self: ReactiveRef<Result.Result<A, E | Cause.NoSuchElementException>>
  ): <R>(stream: Stream.Stream<A, E, R>) => Effect.Effect<void, never, R | Scope.Scope>
  <A, E, R>(
    self: ReactiveRef<Result.Result<A, E | Cause.NoSuchElementException>>,
    stream: Stream.Stream<A, E, R>
  ): Effect.Effect<void, never, R | Scope.Scope>
}

export declare const intoStreamPull: {
  <A, E>(
    self: ReactiveRef<PullResult<A, E>>
  ): <R>(stream: Stream.Stream<A, E, R>) => Effect.Effect<() => void, never, R | Scope.Scope>
  <A, E, R>(
    self: ReactiveRef<PullResult<A, E>>,
    stream: Stream.Stream<A, E, R>
  ): Effect.Effect<() => void, never, R | Scope.Scope>
}

export interface ReactiveRef<in out A> extends ReadonlyReactiveRef<A> {
  readonly [TypeId]: TypeId
  subscribe(notifiable: Notifiable): void
  unsafeSet(value: A): void
  value: A
}

export interface ReadonlyReactiveRef<out A> extends Handle, Effect.Effect<A, never, Reactive> {
  readonly [TypeId]: TypeId
  subscribe(notifiable: Notifiable): void
  value: A
}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId