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

export declare const getResult: <A, E>(
  self: Atom<Result.Result<A, E>>,
  options?: { readonly suspendOnWaiting?: boolean | undefined }
) => Effect.Effect<A, E, AtomRegistry>

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

export declare const refresh: <A>(self: Atom<A>) => Effect.Effect<void, never, AtomRegistry>

export declare const set: {
  <W>(value: W): <R>(self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>
  <R, W>(self: Writable<R, W>, value: W): Effect.Effect<void, never, AtomRegistry>
}

export declare const toStream: <A>(self: Atom<A>) => Stream.Stream<A, never, AtomRegistry>

export declare const toStreamResult: <A, E>(self: Atom<Result.Result<A, E>>) => Stream.Stream<A, E, AtomRegistry>

export declare const update: {
  <R, W>(f: (_: R) => W): (self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>
  <R, W>(self: Writable<R, W>, f: (_: R) => W): Effect.Effect<void, never, AtomRegistry>
}

export declare const makeRefreshOnSignal: <_>(
  signal: Atom<_>
) => <A extends Atom<any>>(self: A) => WithoutSerializable<A>

export declare const refreshOnWindowFocus: <A extends Atom<any>>(self: A) => WithoutSerializable<A>

export declare const windowFocusSignal: Atom<number>

export declare const isAtom: (u: unknown) => u is Atom<any>

export declare const kvs: <A>(options: {
  readonly runtime: AtomRuntime<KeyValueStore.KeyValueStore, any>
  readonly key: string
  readonly schema: Schema.Schema<A, any>
  readonly defaultValue: LazyArg<A>
}) => Writable<A>

export declare const optimistic: <A>(self: Atom<A>) => Writable<A, Atom<Result.Result<A, unknown>>>

export declare const optimisticFn: {
  <A, W, XA, XE, OW = void>(options: {
    readonly reducer: (current: NoInfer<A>, update: OW) => NoInfer<W>
    readonly fn: AtomResultFn<OW, XA, XE> | ((set: (result: NoInfer<W>) => void) => AtomResultFn<OW, XA, XE>)
  }): (self: Writable<A, Atom<Result.Result<W, unknown>>>) => AtomResultFn<OW, XA, XE>
  <A, W, XA, XE, OW = void>(
    self: Writable<A, Atom<Result.Result<W, unknown>>>,
    options: {
      readonly reducer: (current: NoInfer<A>, update: OW) => NoInfer<W>
      readonly fn: AtomResultFn<OW, XA, XE> | ((set: (result: NoInfer<W>) => void) => AtomResultFn<OW, XA, XE>)
    }
  ): AtomResultFn<OW, XA, XE>
}

export declare const withReactivity: (
  keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>
) => <A extends Atom<any>>(atom: A) => A

export interface Serializable {
  readonly [SerializableTypeId]: {
    readonly key: string
    readonly encode: (value: unknown) => unknown
    readonly decode: (value: unknown) => unknown
  }
}

export declare const SerializableTypeId: "~effect-atom/atom/Atom/Serializable"

export type SerializableTypeId = "~effect-atom/atom/Atom/Serializable"

export declare const isSerializable: (self: Atom<any>) => self is Atom<any> & Serializable

export declare const ServerValueTypeId: "~effect-atom/atom/Atom/ServerValue"

export declare const getServerValue: {
  (registry: Registry.Registry): <A>(self: Atom<A>) => A
  <A>(self: Atom<A>, registry: Registry.Registry): A
}

export declare const withServerValue: {
  <A extends Atom<any>>(read: (get: <A>(atom: Atom<A>) => A) => Type<A>): (self: A) => A
  <A extends Atom<any>>(self: A, read: (get: <A>(atom: Atom<A>) => A) => Type<A>): A
}

export declare const withServerValueInitial: <A extends Atom<Result.Result<any, any>>>(self: A) => A

export declare const searchParam: <A = never, I extends string = never>(
  name: string,
  options?: { readonly schema?: Schema.Schema<A, I> }
) => Writable<[A] extends [never] ? string : Option.Option<A>>

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

export declare const autoDispose: <A extends Atom<any>>(self: A) => A

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

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

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

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

export declare const mapResult: {
  <R extends Atom<Result.Result<any, any>>, B>(
    f: (_: Result.Result.Success<Type<R>>) => B
  ): (
    self: R
  ) => [R] extends [Writable<infer _, infer RW>]
    ? Writable<Result.Result<B, Result.Result.Failure<Type<R>>>, RW>
    : Atom<Result.Result<B, Result.Result.Failure<Type<R>>>>
  <R extends Atom<Result.Result<any, any>>, B>(
    self: R,
    f: (_: Result.Result.Success<Type<R>>) => B
  ): [R] extends [Writable<infer _, infer RW>]
    ? Writable<Result.Result<B, Result.Result.Failure<Type<R>>>, RW>
    : Atom<Result.Result<B, Result.Result.Failure<Type<R>>>>
}

export declare const serializable: {
  <R extends Atom<any>, I>(options: {
    readonly key: string
    readonly schema: Schema.Schema<Type<R>, I>
  }): (self: R) => R & Serializable
  <R extends Atom<any>, I>(
    self: R,
    options: { readonly key: string; readonly schema: Schema.Schema<Type<R>, I> }
  ): R & Serializable
}

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

export declare const setLazy: {
  (lazy: boolean): <A extends Atom<any>>(self: A) => A
  <A extends Atom<any>>(self: A, lazy: boolean): A
}

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

export declare const withFallback: {
  <E2, A2>(
    fallback: Atom<Result.Result<A2, E2>>
  ): <R extends Atom<Result.Result<any, any>>>(
    self: R
  ) => [R] extends [Writable<infer _, infer RW>]
    ? Writable<Result.Result<Result.Result.Success<Type<R>> | A2, Result.Result.Failure<Type<R>> | E2>, RW>
    : Atom<Result.Result<Result.Result.Success<Type<R>> | A2, Result.Result.Failure<Type<R>> | E2>>
  <R extends Atom<Result.Result<any, any>>, A2, E2>(
    self: R,
    fallback: Atom<Result.Result<A2, E2>>
  ): [R] extends [Writable<infer _, infer RW>]
    ? Writable<Result.Result<Result.Result.Success<Type<R>> | A2, Result.Result.Failure<Type<R>> | E2>, RW>
    : Atom<Result.Result<Result.Result.Success<Type<R>> | A2, Result.Result.Failure<Type<R>> | E2>>
}

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

export declare const context: (options: { readonly memoMap: Layer.MemoMap }) => RuntimeFactory

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

export declare const fn: {
  <Arg>(): <E, A>(
    fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>,
    options?: { readonly initialValue?: A | undefined }
  ) => AtomResultFn<Arg, A, E>
  <E, A, Arg = void>(
    fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>,
    options?: { readonly initialValue?: A | undefined }
  ): AtomResultFn<Arg, A, E>
  <Arg>(): <E, A>(
    fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry>,
    options?: { readonly initialValue?: A | undefined }
  ) => AtomResultFn<Arg, A, E | NoSuchElementException>
  <E, A, Arg = void>(
    fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry>,
    options?: { readonly initialValue?: A | undefined }
  ): AtomResultFn<Arg, A, E | NoSuchElementException>
}

export declare const fnSync: {
  <Arg>(): {
    <A>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>
    <A>(f: (arg: Arg, get: FnContext) => A, options: { readonly initialValue: A }): Writable<A, Arg>
  }
  <A, Arg = void>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>
  <A, Arg = void>(f: (arg: Arg, get: FnContext) => A, options: { readonly initialValue: A }): Writable<A, Arg>
}

export declare const make: {
  <A, E>(
    create: (get: Context) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>,
    options?: { readonly initialValue?: A }
  ): Atom<Result.Result<A, E>>
  <A, E>(
    effect: Effect.Effect<A, E, Scope.Scope | AtomRegistry>,
    options?: { readonly initialValue?: A }
  ): Atom<Result.Result<A, E>>
  <A, E>(
    create: (get: Context) => Stream.Stream<A, E, AtomRegistry>,
    options?: { readonly initialValue?: A }
  ): Atom<Result.Result<A, E>>
  <A, E>(stream: Stream.Stream<A, E, AtomRegistry>, options?: { readonly initialValue?: A }): Atom<Result.Result<A, E>>
  <A>(create: (get: Context) => A): Atom<A>
  <A>(initialValue: A): Writable<A>
}

export declare const pull: <A, E>(
  create: ((get: Context) => Stream.Stream<A, E, AtomRegistry>) | Stream.Stream<A, E, AtomRegistry>,
  options?: { readonly disableAccumulation?: boolean }
) => Writable<PullResult<A, E>, void>

export declare const readable: <A>(
  read: (get: Context) => A,
  refresh?: (f: <A>(atom: Atom<A>) => void) => void
) => Atom<A>

export declare const subscribable: {
  <A, E>(ref: Subscribable.Subscribable<A, E> | ((get: Context) => Subscribable.Subscribable<A, E>)): Atom<A>
  <A, E, E1>(
    effect:
      | Effect.Effect<Subscribable.Subscribable<A, E1>, E, Scope.Scope | AtomRegistry>
      | ((get: Context) => Effect.Effect<Subscribable.Subscribable<A, E1>, E, Scope.Scope | AtomRegistry>)
  ): Atom<Result.Result<A, E | E1>>
}

export declare const subscriptionRef: {
  <A>(ref: SubscriptionRef.SubscriptionRef<A> | ((get: Context) => SubscriptionRef.SubscriptionRef<A>)): Writable<A>
  <A, E>(
    effect:
      | Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry>
      | ((get: Context) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry>)
  ): Writable<Result.Result<A, E>, A>
}

export declare const writable: <R, W>(
  read: (get: Context) => R,
  write: (ctx: WriteContext<R>, value: W) => void,
  refresh?: (f: <A>(atom: Atom<A>) => void) => void
) => Writable<R, W>

export interface Context {
  <A>(atom: Atom<A>): A
  readonly get: <A>(atom: Atom<A>) => A
  readonly result: <A, E>(
    atom: Atom<Result.Result<A, E>>,
    options?: {
      readonly suspendOnWaiting?: boolean | undefined
    }
  ) => Effect.Effect<A, E>
  readonly resultOnce: <A, E>(
    atom: Atom<Result.Result<A, E>>,
    options?: {
      readonly suspendOnWaiting?: boolean | undefined
    }
  ) => Effect.Effect<A, E>
  readonly once: <A>(atom: Atom<A>) => A
  readonly addFinalizer: (f: () => void) => void
  readonly mount: <A>(atom: Atom<A>) => void
  readonly refresh: <A>(atom: Atom<A>) => void
  readonly refreshSelf: () => void
  readonly self: <A>() => Option.Option<A>
  readonly setSelf: <A>(a: A) => void
  readonly set: <R, W>(atom: Writable<R, W>, value: W) => void
  readonly some: <A>(atom: Atom<Option.Option<A>>) => Effect.Effect<A>
  readonly someOnce: <A>(atom: Atom<Option.Option<A>>) => Effect.Effect<A>
  readonly stream: <A>(
    atom: Atom<A>,
    options?: {
      readonly withoutInitialValue?: boolean
      readonly bufferSize?: number
    }
  ) => Stream.Stream<A>
  readonly streamResult: <A, E>(
    atom: Atom<Result.Result<A, E>>,
    options?: {
      readonly withoutInitialValue?: boolean
      readonly bufferSize?: number
    }
  ) => Stream.Stream<A, E>
  readonly subscribe: <A>(
    atom: Atom<A>,
    f: (_: A) => void,
    options?: {
      readonly immediate?: boolean
    }
  ) => void
  readonly registry: Registry.Registry
}

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

export declare const defaultMemoMap: Layer.MemoMap

export declare const runtime: RuntimeFactory

export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
  readonly [TypeId]: TypeId
  readonly keepAlive: boolean
  readonly lazy: boolean
  readonly read: (get: Context) => A
  readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void
  readonly label?: readonly [name: string, stack: string]
  readonly idleTTL?: number
}

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

export interface AtomRuntime<R, ER = never> extends Atom<Result.Result<Runtime.Runtime<R>, ER>> {
  readonly factory: RuntimeFactory

  readonly layer: Atom<Layer.Layer<R, ER>>

  readonly atom: {
    <A, E>(
      create: (get: Context) => Effect.Effect<A, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>,
      options?: {
        readonly initialValue?: A
      }
    ): Atom<Result.Result<A, E | ER>>
    <A, E>(
      effect: Effect.Effect<A, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>,
      options?: {
        readonly initialValue?: A
      }
    ): Atom<Result.Result<A, E | ER>>
    <A, E>(
      create: (get: Context) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>,
      options?: {
        readonly initialValue?: A
      }
    ): Atom<Result.Result<A, E | ER>>
    <A, E>(
      stream: Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>,
      options?: {
        readonly initialValue?: A
      }
    ): Atom<Result.Result<A, E | ER>>
  }

  readonly fn: {
    <Arg>(): {
      <E, A>(
        fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry | Reactivity.Reactivity | R>,
        options?: {
          readonly initialValue?: A | undefined
          readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
        }
      ): AtomResultFn<Arg, A, E | ER>
      <E, A>(
        fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>,
        options?: {
          readonly initialValue?: A | undefined
          readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
        }
      ): AtomResultFn<Arg, A, E | ER | NoSuchElementException>
    }
    <E, A, Arg = void>(
      fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry | Reactivity.Reactivity | R>,
      options?: {
        readonly initialValue?: A | undefined
        readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
      }
    ): AtomResultFn<Arg, A, E | ER>
    <E, A, Arg = void>(
      fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>,
      options?: {
        readonly initialValue?: A | undefined
        readonly reactivityKeys?: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>> | undefined
      }
    ): AtomResultFn<Arg, A, E | ER | NoSuchElementException>
  }

  readonly pull: <A, E>(
    create:
      | ((get: Context) => Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>)
      | Stream.Stream<A, E, R | AtomRegistry | Reactivity.Reactivity>,
    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 | AtomRegistry | Reactivity.Reactivity>
      | ((
          get: Context
        ) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, R | AtomRegistry | Reactivity.Reactivity>)
  ) => Writable<Result.Result<A, E>, A>

  readonly subscribable: <A, E, E1 = never>(
    create:
      | Effect.Effect<Subscribable.Subscribable<A, E, R>, E1, R | AtomRegistry | Reactivity.Reactivity>
      | ((
          get: Context
        ) => Effect.Effect<Subscribable.Subscribable<A, E, R>, E1, R | AtomRegistry | Reactivity.Reactivity>)
  ) => Atom<Result.Result<A, E | E1>>
}

export interface FnContext extends Omit<Context, "get" | "once" | "resultOnce" | "someOnce" | "refreshSelf"> {
  <A>(atom: Atom<A>): A
}

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

export interface RuntimeFactory {
  <R, E>(
    create:
      | Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>
      | ((get: Context) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)
  ): AtomRuntime<R, E>
  readonly memoMap: Layer.MemoMap
  readonly addGlobalLayer: <A, E>(layer: Layer.Layer<A, E, AtomRegistry | Reactivity.Reactivity>) => void

  /**
   * Uses the `Reactivity` service from the runtime to refresh the atom whenever
   * the keys change.
   */
  readonly withReactivity: (
    keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>
  ) => <A extends Atom<any>>(atom: A) => A
}

export interface Writable<R, W = R> extends Atom<R> {
  readonly [WritableTypeId]: WritableTypeId
  readonly write: (ctx: WriteContext<R>, value: W) => void
}

export declare const isWritable: <R, W>(atom: Atom<R>) => atom is Writable<R, W>

export declare const Reset: typeof Reset

export type Reset = typeof Reset

export declare const TypeId: "~effect-atom/atom/Atom"

export type TypeId = "~effect-atom/atom/Atom"

export declare const WritableTypeId: "~effect-atom/atom/Atom/Writable"

export type WritableTypeId = "~effect-atom/atom/Atom/Writable"

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

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

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

export type Type<T extends Atom<any>> = T extends Atom<infer A> ? A : never

export type WithoutSerializable<T extends Atom<any>> =
  T extends Writable<infer R, infer W> ? Writable<R, W> : Atom<Type<T>>