export declare const make: <A>(value: A) => Effect.Effect<SubscriptionRef<A>, never, never>

export declare const get: <A>(self: SubscriptionRef<A>) => Effect.Effect<A, never, never>

export interface SubscriptionRef<in out A>
  extends SubscriptionRef.Variance<A>,
    Synchronized.SynchronizedRef<A>,
    Subscribable<A> {
  /** @internal */
  readonly ref: Ref.Ref<A>
  /** @internal */
  readonly pubsub: PubSub.PubSub<A>
  /** @internal */
  readonly semaphore: Effect.Semaphore
  /**
   * A stream containing the current value of the `Ref` as well as all changes
   * to that value.
   */
  readonly changes: Stream.Stream<A>
}

export declare const SubscriptionRefTypeId: typeof SubscriptionRefTypeId

export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId

export interface Variance<in out A> {
  readonly [SubscriptionRefTypeId]: {
    readonly _A: Types.Invariant<A>
  }
}

export declare const getAndSet: {
  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<A, never, never>
  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A, never, never>
}

export declare const getAndUpdate: {
  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<A, never, never>
  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<A, never, never>
}

export declare const getAndUpdateEffect: {
  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
}

export declare const getAndUpdateSome: {
  <A>(pf: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<A, never, never>
  <A>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A, never, never>
}

export declare const getAndUpdateSomeEffect: {
  <A, R, E>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
  <A, R, E>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R>
}

export declare const modify: {
  <A, B>(f: (a: A) => readonly [B, A]): (self: SubscriptionRef<A>) => Effect.Effect<B, never, never>
  <A, B>(self: SubscriptionRef<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B, never, never>
}

export declare const modifyEffect: {
  <B, A, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): (self: SubscriptionRef<A>) => Effect.Effect<B, E, R>
  <A, B, E, R>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R>
}

export declare const modifySome: {
  <B, A>(
    fallback: B,
    pf: (a: A) => Option.Option<readonly [B, A]>
  ): (self: SubscriptionRef<A>) => Effect.Effect<B, never, never>
  <A, B>(
    self: SubscriptionRef<A>,
    fallback: B,
    pf: (a: A) => Option.Option<readonly [B, A]>
  ): Effect.Effect<B, never, never>
}

export declare const modifySomeEffect: {
  <A, B, R, E>(
    fallback: B,
    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
  ): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<B, E, R>
  <A, B, R, E>(
    self: Synchronized.SynchronizedRef<A>,
    fallback: B,
    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
  ): Effect.Effect<B, E, R>
}

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

export declare const setAndGet: {
  <A>(value: A): (self: SubscriptionRef<A>) => Effect.Effect<A, never, never>
  <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A, never, never>
}

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

export declare const updateAndGet: {
  <A>(f: (a: A) => A): (self: SubscriptionRef<A>) => Effect.Effect<A, never, never>
  <A>(self: SubscriptionRef<A>, f: (a: A) => A): Effect.Effect<A, never, never>
}

export declare const updateAndGetEffect: {
  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
  <A, R, E>(self: SubscriptionRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
}

export declare const updateEffect: {
  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>
  <A, R, E>(self: Synchronized.SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<void, E, R>
}

export declare const updateSome: {
  <A>(f: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<void>
  <A>(self: SubscriptionRef<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>
}

export declare const updateSomeAndGet: {
  <A>(pf: (a: A) => Option.Option<A>): (self: SubscriptionRef<A>) => Effect.Effect<A, never, never>
  <A>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A, never, never>
}

export declare const updateSomeAndGetEffect: {
  <A, R, E>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): (self: SubscriptionRef<A>) => Effect.Effect<A, E, R>
  <A, R, E>(self: SubscriptionRef<A>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R>
}

export declare const updateSomeEffect: {
  <A, R, E>(
    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
  ): (self: Synchronized.SynchronizedRef<A>) => Effect.Effect<void, E, R>
  <A, R, E>(
    self: Synchronized.SynchronizedRef<A>,
    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
  ): Effect.Effect<void, E, R>
}