export declare const batch: (f: () => void) => void

export declare const debounce: {
  (duration: Duration.DurationInput): <A extends Rx<any>>(self: A) => A
  <A extends Rx<any>>(self: A, duration: Duration.DurationInput): A
}

export declare const initialValue: {
  <A>(initialValue: A): (self: Rx<A>) => readonly [Rx<A>, A]
  <A>(self: Rx<A>, initialValue: A): readonly [Rx<A>, A]
}

export declare const keepAlive: <A extends Rx<any>>(self: A) => A

export declare const map: {
  <R extends Rx<any>, B>(
    f: (_: Rx.Infer<R>) => B
  ): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Rx<B>
  <R extends Rx<any>, B>(
    self: R,
    f: (_: Rx.Infer<R>) => B
  ): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Rx<B>
}

export declare const mapResult: {
  <R extends Rx<Result.Result<any, any>>, B>(
    f: (_: Result.Result.InferA<Rx.Infer<R>>) => B
  ): (
    self: R
  ) => [R] extends [Writable<infer _, infer RW>]
    ? Writable<Result.Result<B, Result.Result.InferE<Rx.Infer<R>>>, RW>
    : Rx<Result.Result<B, Result.Result.InferE<Rx.Infer<R>>>>
  <R extends Rx<Result.Result<any, any>>, B>(
    self: R,
    f: (_: Result.Result.InferA<Rx.Infer<R>>) => B
  ): [R] extends [Writable<infer _, infer RW>]
    ? Writable<Result.Result<B, Result.Result.InferE<Rx.Infer<R>>>, RW>
    : Rx<Result.Result<B, Result.Result.InferE<Rx.Infer<R>>>>
}

export declare const refreshable: <T extends Rx<any>>(self: T) => T & Refreshable

export declare const setIdleTTL: {
  (duration: Duration.DurationInput): <A extends Rx<any>>(self: A) => A
  <A extends Rx<any>>(self: A, duration: Duration.DurationInput): A
}

export declare const transform: {
  <R extends Rx<any>, B>(
    f: (get: Context) => B
  ): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Rx<B>
  <R extends Rx<any>, B>(
    self: R,
    f: (get: Context) => B
  ): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Rx<B>
}

export declare const withFallback: {
  <E2, A2>(
    fallback: Rx<Result.Result<A2, E2>>
  ): <R extends Rx<Result.Result<any, any>>>(
    self: R
  ) => [R] extends [Writable<infer _, infer RW>]
    ? Writable<Result.Result<A2 | Result.Result.InferA<Rx.Infer<R>>, E2 | Result.Result.InferE<Rx.Infer<R>>>, RW>
    : Rx<Result.Result<A2 | Result.Result.InferA<Rx.Infer<R>>, E2 | Result.Result.InferE<Rx.Infer<R>>>>
  <R extends Rx<Result.Result<any, any>>, A2, E2>(
    self: R,
    fallback: Rx<Result.Result<A2, E2>>
  ): [R] extends [Writable<infer _, infer RW>]
    ? Writable<Result.Result<A2 | Result.Result.InferA<Rx.Infer<R>>, E2 | Result.Result.InferE<Rx.Infer<R>>>, RW>
    : Rx<Result.Result<A2 | Result.Result.InferA<Rx.Infer<R>>, E2 | Result.Result.InferE<Rx.Infer<R>>>>
}

export declare const withLabel: {
  (name: string): <A extends Rx<any>>(self: A) => A
  <A extends Rx<any>>(self: A, name: string): A
}

export declare const context: () => <R, E>(
  create: Layer.Layer<R, E, never> | Rx.Read<Layer.Layer<R, E, never>>
) => RxRuntime<R, E>

export declare const family: <Arg, T extends object>(f: (arg: Arg) => T) => (arg: Arg) => T

export declare const fn: {
  <Arg, E, A>(
    fn: Rx.ReadFn<Arg, Effect.Effect<A, E, Scope.Scope>>,
    options?: { readonly initialValue?: A | undefined } | undefined
  ): RxResultFn<RxResultFn.ArgToVoid<Arg>, A, E>
  <Arg, E, A>(
    fn: Rx.ReadFn<Arg, Stream.Stream<A, E, never>>,
    options?: { readonly initialValue?: A | undefined } | undefined
  ): RxResultFn<RxResultFn.ArgToVoid<Arg>, A, NoSuchElementException | E>
}

export declare const fnSync: {
  <Arg, A>(f: Rx.ReadFn<Arg, A>): Writable<Option.Option<A>, RxResultFn.ArgToVoid<Arg>>
  <Arg, A>(f: Rx.ReadFn<Arg, A>, options: { readonly initialValue: A }): Writable<A, RxResultFn.ArgToVoid<Arg>>
}

export declare const make: {
  <A, E>(
    effect: Effect.Effect<A, E, Scope.Scope>,
    options?: { readonly initialValue?: A | undefined } | undefined
  ): Rx<Result.Result<A, E>>
  <A, E>(
    create: Rx.Read<Effect.Effect<A, E, Scope.Scope>>,
    options?: { readonly initialValue?: A | undefined } | undefined
  ): Rx<Result.Result<A, E>>
  <A, E>(
    stream: Stream.Stream<A, E, never>,
    options?: { readonly initialValue?: A | undefined } | undefined
  ): Rx<Result.Result<A, E>>
  <A, E>(
    create: Rx.Read<Stream.Stream<A, E, never>>,
    options?: { readonly initialValue?: A | undefined } | undefined
  ): Rx<Result.Result<A, E>>
  <A>(create: Rx.Read<A>): Rx<A>
  <A>(initialValue: A): Writable<A, A>
}

export declare const pull: <A, E>(
  create: Stream.Stream<A, E, never> | Rx.Read<Stream.Stream<A, E, never>>,
  options?:
    | { readonly disableAccumulation?: boolean | undefined; readonly initialValue?: readonly A[] | undefined }
    | undefined
) => Writable<PullResult<A, E>, void>

export declare const readable: <A>(read: Rx.Read<A>, refresh?: Rx.Refresh) => Rx<A>

export declare const subscribable: {
  <A, E>(ref: Subscribable.Subscribable<A, E, never> | Rx.Read<Subscribable.Subscribable<A, E, never>>): Rx<A>
  <A, E, E1>(
    effect:
      | Effect.Effect<Subscribable.Subscribable<A, E1, never>, E, never>
      | Rx.Read<Effect.Effect<Subscribable.Subscribable<A, E1, never>, E, never>>
  ): Rx<A>
}

export declare const subscriptionRef: {
  <A>(ref: SubscriptionRef.SubscriptionRef<A> | Rx.Read<SubscriptionRef.SubscriptionRef<A>>): Writable<A, A>
  <A, E>(
    effect:
      | Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, never>
      | Rx.Read<Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, never>>
  ): Writable<Result.Result<A, E>, A>
}

export declare const writable: <R, W>(read: Rx.Read<R>, write: Rx.Write<R, W>, refresh?: Rx.Refresh) => Writable<R, W>

export interface Context {
  <A>(rx: Rx<A>): A
  readonly get: <A>(rx: Rx<A>) => A
  readonly result: <A, E>(rx: Rx<Result.Result<A, E>>) => Effect.Effect<A, E>
  readonly once: <A>(rx: Rx<A>) => A
  readonly addFinalizer: (f: () => void) => void
  readonly mount: <A>(rx: Rx<A>) => void
  readonly refreshSync: <A>(rx: Rx<A> & Refreshable) => void
  readonly refresh: <A>(rx: Rx<A> & Refreshable) => Effect.Effect<void>
  readonly refreshSelfSync: () => void
  readonly refreshSelf: Effect.Effect<void>
  readonly self: <A>() => Option.Option<A>
  readonly setSelfSync: <A>(a: A) => void
  readonly setSelf: <A>(a: A) => Effect.Effect<void>
  readonly setSync: <R, W>(rx: Writable<R, W>, value: W) => void
  readonly set: <R, W>(rx: Writable<R, W>, value: W) => Effect.Effect<void>
  readonly some: <A>(rx: Rx<Option.Option<A>>) => Effect.Effect<A>
  readonly stream: <A>(
    rx: Rx<A>,
    options?: {
      readonly withoutInitialValue?: boolean
      readonly bufferSize?: number
    }
  ) => Stream.Stream<A>
  readonly streamResult: <A, E>(
    rx: Rx<Result.Result<A, E>>,
    options?: {
      readonly withoutInitialValue?: boolean
      readonly bufferSize?: number
    }
  ) => Stream.Stream<A, E>
  readonly subscribe: <A>(
    rx: Rx<A>,
    f: (_: A) => void,
    options?: {
      readonly immediate?: boolean
    }
  ) => void
}

export interface WriteContext<A> {
  readonly get: <A>(rx: Rx<A>) => A
  readonly refreshSelf: () => void
  readonly setSelf: (a: A) => void
  readonly set: <R, W>(rx: Writable<R, W>, value: W) => void
}

export declare const runtime: <R, E>(
  create: Layer.Layer<R, E, never> | Rx.Read<Layer.Layer<R, E, never>>
) => RxRuntime<R, E>

export type PullResult<A, E = never> = Result.Result<
  {
    readonly done: boolean
    readonly items: Array<A>
  },
  E | NoSuchElementException
>

export interface Refreshable {
  readonly [RefreshableTypeId]: RefreshableTypeId
}

export interface Rx<A> extends Pipeable, Inspectable.Inspectable {
  readonly [TypeId]: TypeId
  readonly keepAlive: boolean
  readonly read: Rx.Read<A>
  readonly refresh?: Rx.Refresh
  readonly label?: readonly [name: string, stack: string]
  readonly idleTTL?: number
}

export type Get = <A>(rx: Rx<A>) => A

export type GetResult = <A, E>(rx: Rx<Result.Result<A, E>>) => Effect.Effect<A, E>

export type Infer<T extends Rx<any>> = T extends Rx<infer A> ? A : never

export type InferFailure<T extends Rx<any>> = T extends Rx<Result.Result<infer _, infer E>> ? E : never

export type InferPullSuccess<T extends Rx<any>> = T extends Rx<PullResult<infer A, infer _>> ? A : never

export type InferSuccess<T extends Rx<any>> = T extends Rx<Result.Result<infer A, infer _>> ? A : never

export type Mount = <A>(rx: Rx<A>) => () => void

export type Read<A> = (ctx: Context) => A

export type ReadFn<Arg, A> = (arg: Arg, ctx: Context) => A

export type Refresh = (f: <A>(rx: Rx<A>) => void) => void

export type RefreshRx = <A>(rx: Rx<A> & Refreshable) => Effect.Effect<void>

export type RefreshRxSync = <A>(rx: Rx<A> & Refreshable) => void

export type Set = <R, W>(rx: Writable<R, W>, value: W) => void

export type SetEffect = <R, W>(rx: Writable<R, W>, value: W) => Effect.Effect<void>

export type Subscribe = <A>(
  rx: Rx<A>,
  f: (_: A) => void,
  options?: {
    readonly immediate?: boolean
  }
) => () => void

export type Write<R, W> = (ctx: WriteContext<R>, value: W) => void

export interface RxResultFn<Arg, A, E = never> extends Writable<Result.Result<A, E>, Arg | Reset> {}

export interface RxRuntime<R, ER> extends Rx<Result.Result<Runtime.Runtime<R>, ER>> {
  readonly layer: Rx<Layer.Layer<R, ER>>

  readonly rx: {
    <A, E>(
      effect: Effect.Effect<A, E, Scope.Scope | R>,
      options?: {
        readonly initialValue?: A
      }
    ): Rx<Result.Result<A, E | ER>>
    <A, E>(
      create: Rx.Read<Effect.Effect<A, E, Scope.Scope | R>>,
      options?: {
        readonly initialValue?: A
      }
    ): Rx<Result.Result<A, E | ER>>
    <A, E>(
      stream: Stream.Stream<A, E, never | R>,
      options?: {
        readonly initialValue?: A
      }
    ): Rx<Result.Result<A, E | ER>>
    <A, E>(
      create: Rx.Read<Stream.Stream<A, E, never | R>>,
      options?: {
        readonly initialValue?: A
      }
    ): Rx<Result.Result<A, E | ER>>
  }

  readonly fn: {
    <Arg, E, A>(
      fn: Rx.ReadFn<Arg, Effect.Effect<A, E, Scope.Scope | R>>,
      options?: {
        readonly initialValue?: A
      }
    ): RxResultFn<RxResultFn.ArgToVoid<Arg>, A, E | ER>
    <Arg, E, A>(
      fn: Rx.ReadFn<Arg, Stream.Stream<A, E, R>>,
      options?: {
        readonly initialValue?: A
      }
    ): RxResultFn<RxResultFn.ArgToVoid<Arg>, A, E | ER | NoSuchElementException>
  }

  readonly pull: <A, E>(
    create: Rx.Read<Stream.Stream<A, E, R>> | Stream.Stream<A, E, R>,
    options?: {
      readonly disableAccumulation?: boolean
      readonly initialValue?: ReadonlyArray<A>
    }
  ) => Writable<PullResult<A, E | ER>, void>

  readonly subscriptionRef: <A, E>(
    create:
      | Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, R>
      | Rx.Read<Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, R>>
  ) => Writable<Result.Result<A, E>, A>

  readonly subscribable: <A, E, E1 = never>(
    create:
      | Effect.Effect<Subscribable.Subscribable<A, E, R>, E1, R>
      | Rx.Read<Effect.Effect<Subscribable.Subscribable<A, E, R>, E1, R>>
  ) => Rx<Result.Result<A, E | E1>>
}

export interface Writable<R, W> extends Rx<R> {
  readonly [WritableTypeId]: WritableTypeId
  readonly write: Rx.Write<R, W>
}

export declare const isWritable: <R, W>(rx: Rx<R>) => rx is Writable<R, W>

export declare const Reset: typeof Reset

export type Reset = typeof Reset

export declare const RefreshableTypeId: typeof RefreshableTypeId

export type RefreshableTypeId = typeof RefreshableTypeId

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

export declare const WritableTypeId: typeof WritableTypeId

export type WritableTypeId = typeof WritableTypeId

export type ArgToVoid<Arg> = Arg extends infer A ? (unknown extends A ? void : A extends undefined ? void : A) : never