/**
 * Reactive state primitives for values evaluated by an {@link AtomRegistry}.
 *
 * An {@link Atom} describes how to read a value. The registry is the runtime
 * owner: it evaluates reads, caches results, records dependency edges, runs
 * effects and streams with the configured runtime services, and disposes nodes
 * when they are no longer observed.
 *
 * **Mental model**
 *
 * Regular `get(atom)` calls inside a read function create dependencies. When a
 * dependency changes or refreshes, dependent atoms are invalidated and re-read
 * on demand. One-shot reads such as `get.once(atom)` read the current value
 * without creating an edge. The same atom can hold different cached values in
 * different registries, so stable atom identity matters; use {@link family} for
 * atoms parameterized by input values.
 *
 * **Common tasks**
 *
 * Use {@link readable} or {@link writable} for synchronous state, {@link make}
 * for effects and streams exposed as `AsyncResult`, {@link fn} for
 * command-style effects, {@link pull} for pull-based streams, and
 * {@link subscriptionRef} to expose a `SubscriptionRef`. Use {@link kvs},
 * {@link searchParam}, and {@link serializable} when atom values need
 * persistence, URL state, or server-to-client hydration. Read and mutate atoms
 * from Effect code with {@link get}, {@link set}, {@link update},
 * {@link refresh}, and {@link mount}; convert observed values to streams with
 * {@link toStream} or {@link toStreamResult}.
 *
 * **Gotchas**
 *
 * Cache lifetime belongs to the registry, not the atom object. Unobserved
 * non-`keepAlive` atoms can be disposed immediately or after their idle TTL,
 * which also releases finalizers and may rebuild effects, streams, and derived
 * state on the next read. Runtime-backed atoms refresh only through their
 * registered refresh hooks or explicit `Reactivity` invalidations; reading an
 * `Effect` by itself does not keep external data subscribed.
 *
 * @since 4.0.0
 */
import * as Arr from "../../Array.ts";
import * as Cause from "../../Cause.ts";
import * as Context from "../../Context.ts";
import * as Duration from "../../Duration.ts";
import * as Effect from "../../Effect.ts";
import type { LazyArg } from "../../Function.ts";
import type * as Inspectable from "../../Inspectable.ts";
import * as Layer from "../../Layer.ts";
import * as Option from "../../Option.ts";
import type { Pipeable } from "../../Pipeable.ts";
import type { ReadonlyRecord } from "../../Record.ts";
import * as Schema from "../../Schema.ts";
import * as Scope from "../../Scope.ts";
import * as Stream from "../../Stream.ts";
import * as SubscriptionRef from "../../SubscriptionRef.ts";
import type { NoInfer } from "../../Types.ts";
import * as KeyValueStore from "../persistence/KeyValueStore.ts";
import * as AsyncResult from "./AsyncResult.ts";
import { AtomRegistry } from "./AtomRegistry.ts";
import * as Registry from "./AtomRegistry.ts";
import * as Reactivity from "./Reactivity.ts";
/**
 * Type-level identifier used to recognize `Atom` values.
 *
 * @category type IDs
 * @since 4.0.0
 */
export type TypeId = "~effect/reactivity/Atom";
/**
 * Runtime identifier attached to `Atom` values and used by `isAtom`.
 *
 * @category type IDs
 * @since 4.0.0
 */
export declare const TypeId: TypeId;
/**
 * Reactive value read by an `AtomRegistry`, with metadata controlling caching, laziness, refresh behavior, and initial value targeting.
 *
 * @category models
 * @since 4.0.0
 */
export interface Atom<A> extends Pipeable, Inspectable.Inspectable {
    readonly [TypeId]: TypeId;
    readonly keepAlive: boolean;
    readonly lazy: boolean;
    readonly read: (get: AtomContext) => A;
    readonly refresh?: (f: <A>(atom: Atom<A>) => void) => void;
    readonly label?: readonly [name: string, stack: string];
    readonly idleTTL?: number;
    readonly initialValueTarget?: Atom<A>;
}
/**
 * Returns `true` when a value is an `Atom`.
 *
 * @category guards
 * @since 4.0.0
 */
export declare const isAtom: (u: unknown) => u is Atom<any>;
/**
 * Extracts the value type produced by an `Atom`.
 *
 * @category utility types
 * @since 4.0.0
 */
export type Type<T extends Atom<any>> = T extends Atom<infer A> ? A : never;
/**
 * Extracts the success value type from an atom whose value is an `AsyncResult`.
 *
 * @category utility types
 * @since 4.0.0
 */
export type Success<T extends Atom<any>> = T extends Atom<AsyncResult.AsyncResult<infer A, infer _>> ? A : never;
/**
 * Extracts the item type from an atom whose value is a `PullResult`.
 *
 * @category utility types
 * @since 4.0.0
 */
export type PullSuccess<T extends Atom<any>> = T extends Atom<PullResult<infer A, infer _>> ? A : never;
/**
 * Extracts the failure error type from an atom whose value is an `AsyncResult`.
 *
 * @category utility types
 * @since 4.0.0
 */
export type Failure<T extends Atom<any>> = T extends Atom<AsyncResult.AsyncResult<infer _, infer E>> ? E : never;
/**
 * Returns an atom type without serializable metadata, preserving `Writable` read and write types when the input atom is writable.
 *
 * @category utility types
 * @since 4.0.0
 */
export type WithoutSerializable<T extends Atom<any>> = T extends Writable<infer R, infer W> ? Writable<R, W> : Atom<Type<T>>;
/**
 * Runtime identifier attached to writable atoms and used by `isWritable`.
 *
 * @category type IDs
 * @since 4.0.0
 */
export declare const WritableTypeId: WritableTypeId;
/**
 * Type-level identifier used to recognize writable atoms.
 *
 * @category type IDs
 * @since 4.0.0
 */
export type WritableTypeId = "~effect/reactivity/Atom/Writable";
/**
 * Atom that can also be written to, using a `WriteContext` and an input value to update reactive state.
 *
 * @category models
 * @since 4.0.0
 */
export interface Writable<R, W = R> extends Atom<R> {
    readonly [WritableTypeId]: WritableTypeId;
    readonly write: (ctx: WriteContext<R>, value: W) => void;
}
/**
 * Context passed to atom read functions for reading dependencies, awaiting `AsyncResult` or `Option` values, managing subscriptions and finalizers, refreshing atoms, and updating writable atoms.
 *
 * @category context
 * @since 4.0.0
 */
export interface AtomContext {
    <A>(atom: Atom<A>): A;
    get<A>(this: AtomContext, atom: Atom<A>): A;
    result<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
        readonly suspendOnWaiting?: boolean | undefined;
    }): Effect.Effect<A, E>;
    resultOnce<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
        readonly suspendOnWaiting?: boolean | undefined;
    }): Effect.Effect<A, E>;
    once<A>(this: AtomContext, atom: Atom<A>): A;
    addFinalizer(this: AtomContext, f: () => void): void;
    mount<A>(this: AtomContext, atom: Atom<A>): void;
    refresh<A>(this: AtomContext, atom: Atom<A>): void;
    refreshSelf(this: AtomContext): void;
    self<A>(this: AtomContext): Option.Option<A>;
    setSelf<A>(this: AtomContext, a: A): void;
    set<R, W>(this: AtomContext, atom: Writable<R, W>, value: W): void;
    setResult<A, E, W>(this: AtomContext, atom: Writable<AsyncResult.AsyncResult<A, E>, W>, value: W): Effect.Effect<A, E>;
    some<A>(this: AtomContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>;
    someOnce<A>(this: AtomContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>;
    stream<A>(this: AtomContext, atom: Atom<A>, options?: {
        readonly withoutInitialValue?: boolean;
        readonly bufferSize?: number;
    }): Stream.Stream<A>;
    streamResult<A, E>(this: AtomContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
        readonly withoutInitialValue?: boolean;
        readonly bufferSize?: number;
    }): Stream.Stream<A, E>;
    subscribe<A>(this: AtomContext, atom: Atom<A>, f: (_: A) => void, options?: {
        readonly immediate?: boolean;
    }): void;
    readonly registry: Registry.AtomRegistry;
}
/**
 * Context passed to writable atom write functions for reading atoms, refreshing or setting the current atom, and writing to other writable atoms.
 *
 * @category context
 * @since 4.0.0
 */
export interface WriteContext<A> {
    get<T>(this: WriteContext<A>, atom: Atom<T>): T;
    refreshSelf(this: WriteContext<A>): void;
    setSelf(this: WriteContext<A>, a: A): void;
    set<R, W>(this: WriteContext<A>, atom: Writable<R, W>, value: W): void;
}
/**
 * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const setIdleTTL: {
    /**
     * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive.
     *
     * @category combinators
     * @since 4.0.0
     */
    (duration: Duration.Input): <A extends Atom<any>>(self: A) => A;
    /**
     * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive.
     *
     * @category combinators
     * @since 4.0.0
     */
    <A extends Atom<any>>(self: A, duration: Duration.Input): A;
};
/**
 * Returns `true` when an atom is writable.
 *
 * @category refinements
 * @since 4.0.0
 */
export declare const isWritable: <R, W>(atom: Atom<R>) => atom is Writable<R, W>;
/**
 * Creates a read-only atom from a read function and an optional custom refresh registration callback.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const readable: <A>(read: (get: AtomContext) => A, refresh?: (f: <A_1>(atom: Atom<A_1>) => void) => void) => Atom<A>;
/**
 * Creates a writable atom from read and write functions, with an optional custom refresh registration callback.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const writable: <R, W>(read: (get: AtomContext) => R, write: (ctx: WriteContext<R>, value: W) => void, refresh?: (f: <A>(atom: Atom<A>) => void) => void) => Writable<R, W>;
/**
 * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const make: {
    /**
     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A, E>(create: (get: AtomContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
        readonly initialValue?: A | undefined;
        readonly uninterruptible?: boolean | undefined;
    }): Atom<AsyncResult.AsyncResult<A, E>>;
    /**
     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A, E>(effect: Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
        readonly initialValue?: A;
        readonly uninterruptible?: boolean | undefined;
    }): Atom<AsyncResult.AsyncResult<A, E>>;
    /**
     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry>, options?: {
        readonly initialValue?: A;
    }): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>;
    /**
     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A, E>(stream: Stream.Stream<A, E, AtomRegistry>, options?: {
        readonly initialValue?: A;
    }): Atom<AsyncResult.AsyncResult<A, E | Cause.NoSuchElementError>>;
    /**
     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A>(create: (get: AtomContext) => A): Atom<A>;
    /**
     * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A>(initialValue: A): Writable<A>;
};
/**
 * Atom that builds a `Context` from a `Layer` and exposes constructors for atoms, functions, pulls, and subscription refs that run with that context.
 *
 * @category models
 * @since 4.0.0
 */
export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult<Context.Context<R>, ER>> {
    readonly factory: RuntimeFactory;
    readonly layer: Atom<Layer.Layer<R, ER>>;
    readonly atom: {
        <A, E>(create: (get: AtomContext) => Effect.Effect<A, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>, options?: {
            readonly initialValue?: A;
            readonly uninterruptible?: boolean | undefined;
        }): Atom<AsyncResult.AsyncResult<A, E | ER>>;
        <A, E>(effect: Effect.Effect<A, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>, options?: {
            readonly initialValue?: A;
            readonly uninterruptible?: boolean | undefined;
        }): Atom<AsyncResult.AsyncResult<A, E | ER>>;
        <A, E>(create: (get: AtomContext) => Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
            readonly initialValue?: A;
        }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>;
        <A, E>(stream: Stream.Stream<A, E, AtomRegistry | Reactivity.Reactivity | R>, options?: {
            readonly initialValue?: A;
        }): Atom<AsyncResult.AsyncResult<A, E | ER | Cause.NoSuchElementError>>;
    };
    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;
                readonly concurrent?: boolean | 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;
                readonly concurrent?: boolean | undefined;
            }): AtomResultFn<Arg, A, E | ER | Cause.NoSuchElementError>;
        };
        <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;
            readonly concurrent?: boolean | 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;
            readonly concurrent?: boolean | undefined;
        }): AtomResultFn<Arg, A, E | ER | Cause.NoSuchElementError>;
    };
    readonly pull: <A, E>(create: ((get: AtomContext) => 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, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity> | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>)) => Writable<AsyncResult.AsyncResult<A, E>, A>;
}
/**
 * Factory for `AtomRuntime` values that share a `Layer.MemoMap` and a set of global layers.
 *
 * @category models
 * @since 4.0.0
 */
export interface RuntimeFactory {
    <R, E>(create: Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity> | ((get: AtomContext) => 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;
}
/**
 * Creates a `RuntimeFactory` backed by the supplied `Layer.MemoMap`.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const context: (options: {
    readonly memoMap: Layer.MemoMap;
}) => RuntimeFactory;
/**
 * Default `Layer.MemoMap` used by the module-level `runtime` factory.
 *
 * @category context
 * @since 4.0.0
 */
export declare const defaultMemoMap: Layer.MemoMap;
/**
 * Default `RuntimeFactory` created with `defaultMemoMap`.
 *
 * @category context
 * @since 4.0.0
 */
export declare const runtime: RuntimeFactory;
/**
 * Returns `Rx.runtime.withReactivity` for refreshing an atom whenever the
 * keys change in the `Reactivity` service.
 *
 * **When to use**
 *
 * Use to refresh an atom whenever one or more invalidation keys change in the
 * default reactivity runtime.
 *
 * @category reactivity
 * @since 4.0.0
 */
export declare const withReactivity: (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) => <A extends Atom<any>>(atom: A) => A;
/**
 * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const subscriptionRef: {
    /**
     * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A>(ref: SubscriptionRef.SubscriptionRef<A> | ((get: AtomContext) => SubscriptionRef.SubscriptionRef<A>)): Writable<A>;
    /**
     * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A, E>(effect: Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry> | ((get: AtomContext) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | AtomRegistry>)): Writable<AsyncResult.AsyncResult<A, E>, A>;
};
/**
 * Context passed to `fn` and `fnSync` computations for reading atoms, awaiting results, registering finalizers, refreshing atoms, subscribing to changes, and writing updates.
 *
 * @category models
 * @since 4.0.0
 */
export interface FnContext {
    <A>(atom: Atom<A>): A;
    result<A, E>(this: FnContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
        readonly suspendOnWaiting?: boolean | undefined;
    }): Effect.Effect<A, E>;
    addFinalizer(this: FnContext, f: () => void): void;
    mount<A>(this: FnContext, atom: Atom<A>): void;
    refresh<A>(this: FnContext, atom: Atom<A>): void;
    self<A>(this: FnContext): Option.Option<A>;
    setSelf<A>(this: FnContext, a: A): void;
    set<R, W>(this: FnContext, atom: Writable<R, W>, value: W): void;
    setResult<A, E, W>(this: FnContext, atom: Writable<AsyncResult.AsyncResult<A, E>, W>, value: W): Effect.Effect<A, E>;
    some<A>(this: FnContext, atom: Atom<Option.Option<A>>): Effect.Effect<A>;
    stream<A>(this: FnContext, atom: Atom<A>, options?: {
        readonly withoutInitialValue?: boolean;
        readonly bufferSize?: number;
    }): Stream.Stream<A>;
    streamResult<A, E>(this: FnContext, atom: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
        readonly withoutInitialValue?: boolean;
        readonly bufferSize?: number;
    }): Stream.Stream<A, E>;
    subscribe<A>(this: FnContext, atom: Atom<A>, f: (_: A) => void, options?: {
        readonly immediate?: boolean;
    }): void;
    readonly registry: Registry.AtomRegistry;
}
/**
 * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const fnSync: {
    /**
     * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
     *
     * @category constructors
     * @since 4.0.0
     */
    <Arg>(): {
        /**
         * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
         *
         * @category constructors
         * @since 4.0.0
         */
        <A>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>;
        /**
         * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
         *
         * @category constructors
         * @since 4.0.0
         */
        <A>(f: (arg: Arg, get: FnContext) => A, options: {
            readonly initialValue: A;
        }): Writable<A, Arg>;
    };
    /**
     * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A, Arg = void>(f: (arg: Arg, get: FnContext) => A): Writable<Option.Option<A>, Arg>;
    /**
     * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
     *
     * @category constructors
     * @since 4.0.0
     */
    <A, Arg = void>(f: (arg: Arg, get: FnContext) => A, options: {
        readonly initialValue: A;
    }): Writable<A, Arg>;
};
/**
 * Writable async function atom whose value is an `AsyncResult` and whose writes accept function arguments plus `Reset` and `Interrupt` controls.
 *
 * @category models
 * @since 4.0.0
 */
export interface AtomResultFn<Arg, A, E = never> extends Writable<AsyncResult.AsyncResult<A, E>, Arg | Reset | Interrupt> {
}
/**
 * Defines the control symbol that can be written to an `AtomResultFn` to reset it to its initial state.
 *
 * **When to use**
 *
 * Use to write to an `AtomResultFn` when you need to clear the current async
 * result and return it to the initial state.
 *
 * @category symbols
 * @since 4.0.0
 */
export declare const Reset: unique symbol;
/**
 * Type of the `Reset` control symbol accepted by `AtomResultFn` writes.
 *
 * @category symbols
 * @since 4.0.0
 */
export type Reset = typeof Reset;
/**
 * Defines the control symbol that can be written to an `AtomResultFn` to interrupt the current asynchronous computation.
 *
 * **When to use**
 *
 * Use to write to an `AtomResultFn` when you need to interrupt the currently
 * running async computation.
 *
 * @category symbols
 * @since 4.0.0
 */
export declare const Interrupt: unique symbol;
/**
 * Type of the `Interrupt` control symbol accepted by `AtomResultFn` writes.
 *
 * @category symbols
 * @since 4.0.0
 */
export type Interrupt = typeof Interrupt;
/**
 * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const fn: {
    /**
     * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
     *
     * @category constructors
     * @since 4.0.0
     */
    <Arg>(): <E, A>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
        readonly initialValue?: A | undefined;
        readonly concurrent?: boolean | undefined;
    }) => AtomResultFn<Arg, A, E>;
    /**
     * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
     *
     * @category constructors
     * @since 4.0.0
     */
    <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Effect.Effect<A, E, Scope.Scope | AtomRegistry>, options?: {
        readonly initialValue?: A | undefined;
        readonly concurrent?: boolean | undefined;
    }): AtomResultFn<Arg, A, E>;
    /**
     * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
     *
     * @category constructors
     * @since 4.0.0
     */
    <Arg>(): <E, A>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry>, options?: {
        readonly initialValue?: A | undefined;
        readonly concurrent?: boolean | undefined;
    }) => AtomResultFn<Arg, A, E | Cause.NoSuchElementError>;
    /**
     * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
     *
     * @category constructors
     * @since 4.0.0
     */
    <E, A, Arg = void>(fn: (arg: Arg, get: FnContext) => Stream.Stream<A, E, AtomRegistry>, options?: {
        readonly initialValue?: A | undefined;
        readonly concurrent?: boolean | undefined;
    }): AtomResultFn<Arg, A, E | Cause.NoSuchElementError>;
};
/**
 * `AsyncResult` produced by `pull`, containing a non-empty batch of pulled items and a `done` flag, or `NoSuchElementError` when the stream completes without items.
 *
 * @category models
 * @since 4.0.0
 */
export type PullResult<A, E = never> = AsyncResult.AsyncResult<{
    readonly done: boolean;
    readonly items: Arr.NonEmptyArray<A>;
}, E | Cause.NoSuchElementError>;
/**
 * Creates a writable atom that pulls an initial chunk from a stream and then pulls the next chunk whenever it is written to, accumulating items unless `disableAccumulation` is enabled.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const pull: <A, E>(create: ((get: AtomContext) => Stream.Stream<A, E, AtomRegistry>) | Stream.Stream<A, E, AtomRegistry>, options?: {
    readonly disableAccumulation?: boolean | undefined;
}) => Writable<PullResult<A, E>, void>;
/**
 * Creates a memoized atom factory that returns the same object for the same argument, using weak references for cached values when the platform supports them.
 *
 * @category constructors
 * @since 4.0.0
 */
export declare const family: <Arg, T extends object>(f: (arg: Arg) => T) => (arg: Arg) => T;
/**
 * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const withFallback: {
    /**
     * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result.
     *
     * @category combinators
     * @since 4.0.0
     */
    <E2, A2>(fallback: Atom<AsyncResult.AsyncResult<A2, E2>>): <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>, RW> : Atom<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>>;
    /**
     * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<AsyncResult.AsyncResult<any, any>>, A2, E2>(self: R, fallback: Atom<AsyncResult.AsyncResult<A2, E2>>): [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>, RW> : Atom<AsyncResult.AsyncResult<AsyncResult.AsyncResult.Success<Type<R>> | A2, AsyncResult.AsyncResult.Failure<Type<R>> | E2>>;
};
/**
 * Returns a copy of an atom that remains cached and mounted even when no subscribers are using it.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const keepAlive: <A extends Atom<any>>(self: A) => A;
/**
 * Allows a reactive value to be disposed of when it is not in use.
 *
 * **Details**
 *
 * Atoms have this behavior by default, so use this to undo `keepAlive` on a copied atom.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const autoDispose: <A extends Atom<any>>(self: A) => A;
/**
 * Sets whether an atom should be lazy.
 *
 * **Details**
 *
 * Lazy atoms defer recomputation while they have no active listeners or active
 * non-lazy dependents, rebuilding the next time their value is observed.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const setLazy: {
    /**
     * Sets whether an atom should be lazy.
     *
     * **Details**
     *
     * Lazy atoms defer recomputation while they have no active listeners or active
     * non-lazy dependents, rebuilding the next time their value is observed.
     *
     * @category combinators
     * @since 4.0.0
     */
    (lazy: boolean): <A extends Atom<any>>(self: A) => A;
    /**
     * Sets whether an atom should be lazy.
     *
     * **Details**
     *
     * Lazy atoms defer recomputation while they have no active listeners or active
     * non-lazy dependents, rebuilding the next time their value is observed.
     *
     * @category combinators
     * @since 4.0.0
     */
    <A extends Atom<any>>(self: A, lazy: boolean): A;
};
/**
 * Attaches a diagnostic label to an atom.
 *
 * **Details**
 *
 * The label is used for inspection and debugging metadata and does not change the
 * atom's read or write behavior.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const withLabel: {
    /**
     * Attaches a diagnostic label to an atom.
     *
     * **Details**
     *
     * The label is used for inspection and debugging metadata and does not change the
     * atom's read or write behavior.
     *
     * @category combinators
     * @since 4.0.0
     */
    (name: string): <A extends Atom<any>>(self: A) => A;
    /**
     * Attaches a diagnostic label to an atom.
     *
     * **Details**
     *
     * The label is used for inspection and debugging metadata and does not change the
     * atom's read or write behavior.
     *
     * @category combinators
     * @since 4.0.0
     */
    <A extends Atom<any>>(self: A, name: string): A;
};
/**
 * Pairs an atom with an initial value for registry initialization.
 *
 * **When to use**
 *
 * Use to preload an atom value when constructing or seeding a registry.
 *
 * **Details**
 *
 * The returned tuple can be supplied to `AtomRegistry` initial values so the atom
 * starts with the provided value before it is first rebuilt.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const initialValue: {
    /**
     * Pairs an atom with an initial value for registry initialization.
     *
     * **When to use**
     *
     * Use to preload an atom value when constructing or seeding a registry.
     *
     * **Details**
     *
     * The returned tuple can be supplied to `AtomRegistry` initial values so the atom
     * starts with the provided value before it is first rebuilt.
     *
     * @category combinators
     * @since 4.0.0
     */
    <A>(initialValue: A): (self: Atom<A>) => readonly [Atom<A>, A];
    /**
     * Pairs an atom with an initial value for registry initialization.
     *
     * **When to use**
     *
     * Use to preload an atom value when constructing or seeding a registry.
     *
     * **Details**
     *
     * The returned tuple can be supplied to `AtomRegistry` initial values so the atom
     * starts with the provided value before it is first rebuilt.
     *
     * @category combinators
     * @since 4.0.0
     */
    <A>(self: Atom<A>, initialValue: A): readonly [Atom<A>, A];
};
/**
 * Creates a derived atom by reading another atom with a custom `AtomContext`
 * function.
 *
 * **Details**
 *
 * If the source is writable, the derived atom keeps the source write input and
 * forwards writes to the source. `initialValueTarget` controls which atom receives
 * preloaded initial values for the derived atom.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const transform: {
    /**
     * Creates a derived atom by reading another atom with a custom `AtomContext`
     * function.
     *
     * **Details**
     *
     * If the source is writable, the derived atom keeps the source write input and
     * forwards writes to the source. `initialValueTarget` controls which atom receives
     * preloaded initial values for the derived atom.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<any>, B>(f: (get: AtomContext, atom: R) => B, options?: {
        readonly initialValueTarget?: Atom<B> | undefined;
    }): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
    /**
     * Creates a derived atom by reading another atom with a custom `AtomContext`
     * function.
     *
     * **Details**
     *
     * If the source is writable, the derived atom keeps the source write input and
     * forwards writes to the source. `initialValueTarget` controls which atom receives
     * preloaded initial values for the derived atom.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<any>, B>(self: R, f: (get: AtomContext, atom: R) => B, options?: {
        readonly initialValueTarget?: Atom<B> | undefined;
    }): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
};
/**
 * Maps the current value of an atom with a pure function.
 *
 * **Details**
 *
 * When the source atom is writable, the returned atom remains writable and keeps
 * the source atom's write input type.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const map: {
    /**
     * Maps the current value of an atom with a pure function.
     *
     * **Details**
     *
     * When the source atom is writable, the returned atom remains writable and keeps
     * the source atom's write input type.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<any>, B>(f: (_: Type<R>) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
    /**
     * Maps the current value of an atom with a pure function.
     *
     * **Details**
     *
     * When the source atom is writable, the returned atom remains writable and keeps
     * the source atom's write input type.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<any>, B>(self: R, f: (_: Type<R>) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<B, RW> : Atom<B>;
};
/**
 * Maps the successful value inside an `AsyncResult` atom.
 *
 * **Details**
 *
 * Initial and failure states are preserved, and writable source atoms keep their
 * original write input type.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const mapResult: {
    /**
     * Maps the successful value inside an `AsyncResult` atom.
     *
     * **Details**
     *
     * Initial and failure states are preserved, and writable source atoms keep their
     * original write input type.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<AsyncResult.AsyncResult<any, any>>, B>(f: (_: AsyncResult.AsyncResult.Success<Type<R>>) => B): (self: R) => [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>, RW> : Atom<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>>;
    /**
     * Maps the successful value inside an `AsyncResult` atom.
     *
     * **Details**
     *
     * Initial and failure states are preserved, and writable source atoms keep their
     * original write input type.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<AsyncResult.AsyncResult<any, any>>, B>(self: R, f: (_: AsyncResult.AsyncResult.Success<Type<R>>) => B): [R] extends [Writable<infer _, infer RW>] ? Writable<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>, RW> : Atom<AsyncResult.AsyncResult<B, AsyncResult.AsyncResult.Failure<Type<R>>>>;
};
/**
 * Creates an atom that publishes source changes only after the source has stopped
 * changing for the specified duration.
 *
 * **Details**
 *
 * The current source value is used immediately, and any pending debounce timer is
 * cleared when the derived atom is disposed.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const debounce: {
    /**
     * Creates an atom that publishes source changes only after the source has stopped
     * changing for the specified duration.
     *
     * **Details**
     *
     * The current source value is used immediately, and any pending debounce timer is
     * cleared when the derived atom is disposed.
     *
     * @category combinators
     * @since 4.0.0
     */
    (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
    /**
     * Creates an atom that publishes source changes only after the source has stopped
     * changing for the specified duration.
     *
     * **Details**
     *
     * The current source value is used immediately, and any pending debounce timer is
     * cleared when the derived atom is disposed.
     *
     * @category combinators
     * @since 4.0.0
     */
    <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>;
};
/**
 * Creates a derived atom that reads the source and schedules a refresh after the
 * specified duration.
 *
 * **Details**
 *
 * The scheduled refresh is canceled when the derived atom's lifetime is disposed.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const withRefresh: {
    /**
     * Creates a derived atom that reads the source and schedules a refresh after the
     * specified duration.
     *
     * **Details**
     *
     * The scheduled refresh is canceled when the derived atom's lifetime is disposed.
     *
     * @category combinators
     * @since 4.0.0
     */
    (duration: Duration.Input): <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
    /**
     * Creates a derived atom that reads the source and schedules a refresh after the
     * specified duration.
     *
     * **Details**
     *
     * The scheduled refresh is canceled when the derived atom's lifetime is disposed.
     *
     * @category combinators
     * @since 4.0.0
     */
    <A extends Atom<any>>(self: A, duration: Duration.Input): WithoutSerializable<A>;
};
/**
 * Adds stale-while-revalidate refresh behavior to an async result atom.
 *
 * **Details**
 *
 * Automatic revalidation during reads is skipped while the current value is
 * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
 * forward to the wrapped atom. Use `revalidateOnMount` to control whether stale data should trigger a
 * background refresh on first mount. Use `revalidateOnFocus` to control
 * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const swr: {
    /**
     * Adds stale-while-revalidate refresh behavior to an async result atom.
     *
     * **Details**
     *
     * Automatic revalidation during reads is skipped while the current value is
     * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
     * forward to the wrapped atom. Use `revalidateOnMount` to control whether stale data should trigger a
     * background refresh on first mount. Use `revalidateOnFocus` to control
     * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
     *
     * @category combinators
     * @since 4.0.0
     */
    (options: {
        readonly staleTime: Duration.Input;
        readonly revalidateOnMount?: boolean | undefined;
        readonly revalidateOnFocus?: boolean | "always" | undefined;
        readonly focusSignal?: Atom<any> | undefined;
    }): <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R) => WithoutSerializable<R>;
    /**
     * Adds stale-while-revalidate refresh behavior to an async result atom.
     *
     * **Details**
     *
     * Automatic revalidation during reads is skipped while the current value is
     * fresh within `staleTime`. Manual `refresh` calls remain forceful and always
     * forward to the wrapped atom. Use `revalidateOnMount` to control whether stale data should trigger a
     * background refresh on first mount. Use `revalidateOnFocus` to control
     * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<AsyncResult.AsyncResult<any, any>>>(self: R, options: {
        readonly staleTime: Duration.Input;
        readonly revalidateOnMount?: boolean | undefined;
        readonly revalidateOnFocus?: boolean | "always" | undefined;
        readonly focusSignal?: Atom<any> | undefined;
    }): WithoutSerializable<R>;
};
/**
 * Wraps an atom in a writable optimistic atom.
 *
 * **Details**
 *
 * Writes accept transition atoms containing `AsyncResult` values. Waiting
 * successes are shown optimistically while transitions run; when successful
 * transitions finish, the source atom is refreshed, and failures roll the value
 * back to the latest source value.
 *
 * @category Optimistic
 * @since 4.0.0
 */
export declare const optimistic: <A>(self: Atom<A>) => Writable<A, Atom<AsyncResult.AsyncResult<A, unknown>>>;
/**
 * Creates an `AtomResultFn` that applies an optimistic update before running the
 * underlying mutation.
 *
 * **Details**
 *
 * The reducer computes the provisional value from the current value and mutation
 * input. The wrapped function result then completes the transition or updates the
 * optimistic value through the provided setter callback.
 *
 * @category Optimistic
 * @since 4.0.0
 */
export declare const optimisticFn: {
    /**
     * Creates an `AtomResultFn` that applies an optimistic update before running the
     * underlying mutation.
     *
     * **Details**
     *
     * The reducer computes the provisional value from the current value and mutation
     * input. The wrapped function result then completes the transition or updates the
     * optimistic value through the provided setter callback.
     *
     * @category Optimistic
     * @since 4.0.0
     */
    <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<AsyncResult.AsyncResult<W, unknown>>>) => AtomResultFn<OW, XA, XE>;
    /**
     * Creates an `AtomResultFn` that applies an optimistic update before running the
     * underlying mutation.
     *
     * **Details**
     *
     * The reducer computes the provisional value from the current value and mutation
     * input. The wrapped function result then completes the transition or updates the
     * optimistic value through the provided setter callback.
     *
     * @category Optimistic
     * @since 4.0.0
     */
    <A, W, XA, XE, OW = void>(self: Writable<A, Atom<AsyncResult.AsyncResult<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>;
};
/**
 * Runs synchronous atom updates as a batch.
 *
 * **Details**
 *
 * Stale nodes are rebuilt and listeners are notified after the callback completes,
 * so dependent updates observe the final batched state.
 *
 * @category batching
 * @since 4.0.0
 */
export declare const batch: (f: () => void) => void;
/**
 * Creates a browser-only signal atom that increments when the document becomes visible.
 *
 * **Details**
 *
 * It listens for `visibilitychange` events on `window` and removes the listener
 * when the atom is disposed.
 *
 * @category Focus
 * @since 4.0.0
 */
export declare const windowFocusSignal: Atom<number>;
/**
 * Creates a combinator that refreshes an atom whenever the supplied signal atom
 * changes.
 *
 * **Details**
 *
 * The derived atom also subscribes to the source atom so normal source updates are
 * forwarded to its own value.
 *
 * @category Focus
 * @since 4.0.0
 */
export declare const makeRefreshOnSignal: <_>(signal: Atom<_>) => <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
/**
 * Refreshes an atom whenever `windowFocusSignal` changes.
 *
 * **Details**
 *
 * This helper is browser-only because `windowFocusSignal` depends on `window` and
 * `document.visibilityState`.
 *
 * @category Focus
 * @since 4.0.0
 */
export declare const refreshOnWindowFocus: <A extends Atom<any>>(self: A) => WithoutSerializable<A>;
/**
 * Creates a writable atom backed by a `KeyValueStore` entry.
 *
 * **Details**
 *
 * Values are encoded and decoded with the supplied schema. In sync mode the atom
 * exposes the decoded value and writes the default value when the key is missing;
 * in async mode it exposes an `AsyncResult` of the decoded value.
 *
 * @category KeyValueStore
 * @since 4.0.0
 */
export declare const kvs: <S extends Schema.Codec<any, any>, const Mode extends "sync" | "async" = never>(options: {
    readonly runtime: AtomRuntime<KeyValueStore.KeyValueStore, any>;
    readonly key: string;
    readonly schema: S;
    readonly defaultValue: LazyArg<S["Type"]>;
    readonly mode?: Mode | undefined;
}) => Writable<"async" extends Mode ? AsyncResult.AsyncResult<S["Type"]> : S["Type"], S["Type"]>;
/**
 * Creates an atom that reads and writes a URL search parameter.
 *
 * **Gotchas**
 *
 * If you pass a schema, it has to be synchronous and have no context.
 *
 * @category search params
 * @since 4.0.0
 */
export declare const searchParam: <S extends Schema.Codec<any, string> = never>(name: string, options?: {
    readonly schema?: S | undefined;
}) => Writable<[S] extends [never] ? string : Option.Option<S["Type"]>>;
/**
 * Converts an atom into a stream using the `AtomRegistry` service.
 *
 * **Details**
 *
 * The stream emits the atom's current value immediately and then emits subsequent
 * changes until the stream scope is closed.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const toStream: <A>(self: Atom<A>) => Stream.Stream<A, never, AtomRegistry>;
/**
 * Converts an `AsyncResult` atom into a stream using the `AtomRegistry` service.
 *
 * **Details**
 *
 * Initial results are skipped, successes are emitted as stream values, and
 * failures fail the stream with the result cause.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const toStreamResult: <A, E>(self: Atom<AsyncResult.AsyncResult<A, E>>) => Stream.Stream<A, E, AtomRegistry>;
/**
 * Reads an atom's current value from the `AtomRegistry` service.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const get: <A>(self: Atom<A>) => Effect.Effect<A, never, AtomRegistry>;
/**
 * Reads a writable atom, computes a return value and next write value, writes the
 * next value, and returns the computed result.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const modify: {
    /**
     * Reads a writable atom, computes a return value and next write value, writes the
     * next value, and returns the computed result.
     *
     * @category converting
     * @since 4.0.0
     */
    <R, W, A>(f: (_: R) => [returnValue: A, nextValue: W]): (self: Writable<R, W>) => Effect.Effect<A, never, AtomRegistry>;
    /**
     * Reads a writable atom, computes a return value and next write value, writes the
     * next value, and returns the computed result.
     *
     * @category converting
     * @since 4.0.0
     */
    <R, W, A>(self: Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]): Effect.Effect<A, never, AtomRegistry>;
};
/**
 * Writes a value to a writable atom through the `AtomRegistry` service.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const set: {
    /**
     * Writes a value to a writable atom through the `AtomRegistry` service.
     *
     * @category converting
     * @since 4.0.0
     */
    <W>(value: W): <R>(self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>;
    /**
     * Writes a value to a writable atom through the `AtomRegistry` service.
     *
     * @category converting
     * @since 4.0.0
     */
    <R, W>(self: Writable<R, W>, value: W): Effect.Effect<void, never, AtomRegistry>;
};
/**
 * Updates a writable atom by reading its current value from the registry and
 * writing the value returned by the update function.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const update: {
    /**
     * Updates a writable atom by reading its current value from the registry and
     * writing the value returned by the update function.
     *
     * @category converting
     * @since 4.0.0
     */
    <R, W>(f: (_: R) => W): (self: Writable<R, W>) => Effect.Effect<void, never, AtomRegistry>;
    /**
     * Updates a writable atom by reading its current value from the registry and
     * writing the value returned by the update function.
     *
     * @category converting
     * @since 4.0.0
     */
    <R, W>(self: Writable<R, W>, f: (_: R) => W): Effect.Effect<void, never, AtomRegistry>;
};
/**
 * Reads an `AsyncResult` atom as an effect through the `AtomRegistry` service.
 *
 * **Details**
 *
 * The effect waits while the result is `Initial`, and also while it is waiting
 * when `suspendOnWaiting` is enabled. Successes succeed with the value and
 * failures fail with the result cause.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const getResult: <A, E>(self: Atom<AsyncResult.AsyncResult<A, E>>, options?: {
    readonly suspendOnWaiting?: boolean | undefined;
}) => Effect.Effect<A, E, AtomRegistry>;
/**
 * Runs a refresh request for an atom through the `AtomRegistry` service.
 *
 * **When to use**
 *
 * Use to invalidate and recompute an atom from an Effect that has access to the
 * active registry.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const refresh: <A>(self: Atom<A>) => Effect.Effect<void, never, AtomRegistry>;
/**
 * Mounts an atom in the `AtomRegistry` for the lifetime of the current scope.
 *
 * **Details**
 *
 * Mounting keeps the atom subscribed with a no-op listener until the scope
 * finalizer releases it.
 *
 * @category converting
 * @since 4.0.0
 */
export declare const mount: <A>(self: Atom<A>) => Effect.Effect<void, never, AtomRegistry | Scope.Scope>;
/**
 * The type id used to mark atoms that carry serialization metadata.
 *
 * @category type IDs
 * @since 4.0.0
 */
export declare const SerializableTypeId: SerializableTypeId;
/**
 * The literal type of the serializable atom marker.
 *
 * @category type IDs
 * @since 4.0.0
 */
export type SerializableTypeId = "~effect-atom/atom/Atom/Serializable";
/**
 * Serialization metadata attached to an atom.
 *
 * **Details**
 *
 * The key identifies the atom in dehydrated state, and the encode/decode
 * functions convert between the atom value and the schema encoded value.
 *
 * @category Serializable
 * @since 4.0.0
 */
export interface Serializable<S extends Schema.Top> {
    readonly [SerializableTypeId]: {
        readonly key: string;
        readonly encode: (value: S["Type"]) => S["Encoded"];
        readonly decode: (value: S["Encoded"]) => S["Type"];
    };
}
/**
 * Returns `true` when an atom carries `Serializable` metadata.
 *
 * @category Serializable
 * @since 4.0.0
 */
export declare const isSerializable: (self: Atom<any>) => self is Atom<any> & Serializable<any>;
/**
 * Attaches serialization metadata to an atom using a schema and stable key.
 *
 * **Details**
 *
 * The schema is converted to a JSON codec for synchronous encode/decode, and the
 * key is also used as the atom label when the atom does not already have one.
 *
 * @category combinators
 * @since 4.0.0
 */
export declare const serializable: {
    /**
     * Attaches serialization metadata to an atom using a schema and stable key.
     *
     * **Details**
     *
     * The schema is converted to a JSON codec for synchronous encode/decode, and the
     * key is also used as the atom label when the atom does not already have one.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<any>, S extends Schema.Codec<Type<R>, any>>(options: {
        readonly key: string;
        readonly schema: S;
    }): (self: R) => R & Serializable<S>;
    /**
     * Attaches serialization metadata to an atom using a schema and stable key.
     *
     * **Details**
     *
     * The schema is converted to a JSON codec for synchronous encode/decode, and the
     * key is also used as the atom label when the atom does not already have one.
     *
     * @category combinators
     * @since 4.0.0
     */
    <R extends Atom<any>, S extends Schema.Codec<Type<R>, any>>(self: R, options: {
        readonly key: string;
        readonly schema: S;
    }): R & Serializable<S>;
};
/**
 * The type id used to mark atoms with a server-side read override.
 *
 * @category type IDs
 * @since 4.0.0
 */
export declare const ServerValueTypeId: "~effect-atom/atom/Atom/ServerValue";
/**
 * Sets the value of an Atom when read on the server.
 *
 * @category ServerValue
 * @since 4.0.0
 */
export declare const withServerValue: {
    /**
     * Sets the value of an Atom when read on the server.
     *
     * @category ServerValue
     * @since 4.0.0
     */
    <A extends Atom<any>>(read: (get: <A>(atom: Atom<A>) => A) => Type<A>): (self: A) => A;
    /**
     * Sets the value of an Atom when read on the server.
     *
     * @category ServerValue
     * @since 4.0.0
     */
    <A extends Atom<any>>(self: A, read: (get: <A>(atom: Atom<A>) => A) => Type<A>): A;
};
/**
 * Sets an `AsyncResult` atom's server-side value to
 * `AsyncResult.initial(true)`.
 *
 * @category ServerValue
 * @since 4.0.0
 */
export declare const withServerValueInitial: <A extends Atom<AsyncResult.AsyncResult<any, any>>>(self: A) => A;
/**
 * Reads an atom from a registry, using its server-side read override when one is
 * present.
 *
 * **Details**
 *
 * Nested reads performed by the override are resolved against the same registry.
 *
 * @category ServerValue
 * @since 4.0.0
 */
export declare const getServerValue: {
    /**
     * Reads an atom from a registry, using its server-side read override when one is
     * present.
     *
     * **Details**
     *
     * Nested reads performed by the override are resolved against the same registry.
     *
     * @category ServerValue
     * @since 4.0.0
     */
    (registry: Registry.AtomRegistry): <A>(self: Atom<A>) => A;
    /**
     * Reads an atom from a registry, using its server-side read override when one is
     * present.
     *
     * **Details**
     *
     * Nested reads performed by the override are resolved against the same registry.
     *
     * @category ServerValue
     * @since 4.0.0
     */
    <A>(self: Atom<A>, registry: Registry.AtomRegistry): A;
};
//# sourceMappingURL=Atom.d.ts.map