import type { Option } from "../../Option";
import * as T from "../Task/_core";
import type { Ref, XRef } from "./model";
/**
 * Maps and filters the `get` value of the `XRef` with the specified partial
 * function, returning a `XRef` with a `get` value that succeeds with the
 * result of the partial function if it is defined or else fails with `None`.
 */
export declare const collect: <B, C>(
   pf: (_: B) => Option<C>
) => <EA, EB, A>(_: XRef<EA, EB, A, B>) => XRef<EA, Option<EB>, A, C>;
/**
 * Maps and filters the `get` value of the `XRef` with the specified partial
 * function, returning a `XRef` with a `get` value that succeeds with the
 * result of the partial function if it is defined or else fails with `None`.
 */
export declare const collect_: <EA, EB, A, B, C>(
   _: XRef<EA, EB, A, B>,
   pf: (_: B) => Option<C>
) => XRef<EA, Option<EB>, A, C>;
/**
 * Returns a read only view of the `XRef`.
 */
export declare const readOnly: <EA, EB, A, B>(_: XRef<EA, EB, A, B>) => XRef<EA, EB, never, B>;
/**
 * Returns a write only view of the `XRef`.
 */
export declare const writeOnly: <EA, EB, A, B>(_: XRef<EA, EB, A, B>) => XRef<EA, void, A, never>;
/**
 * Atomically modifies the `XRef` with the specified function, which
 * computes a return value for the modification. This is a more powerful
 * version of `update`.
 */
export declare const modify: <B, A>(
   f: (a: A) => readonly [B, A]
) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.EIO<EA | EB, B>;
/**
 * Atomically modifies the `XRef` with the specified function, which
 * computes a return value for the modification. This is a more powerful
 * version of `update`.
 */
export declare const modify_: <EA, EB, B, A>(self: XRef<EA, EB, A, A>, f: (a: A) => [B, A]) => T.EIO<EA | EB, B>;
/**
 * Atomically modifies the `XRef` with the specified partial function,
 * which computes a return value for the modification if the function is
 * defined on the current value otherwise it returns a default value. This
 * is a more powerful version of `updateSome`.
 */
export declare const modifySome: <B>(
   def: B
) => <A>(f: (a: A) => Option<[B, A]>) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.EIO<EA | EB, B>;
/**
 * Atomically modifies the `XRef` with the specified partial function,
 * which computes a return value for the modification if the function is
 * defined on the current value otherwise it returns a default value. This
 * is a more powerful version of `updateSome`.
 */
export declare const modifySome_: <EA, EB, A, B>(
   self: XRef<EA, EB, A, A>,
   def: B,
   f: (a: A) => Option<[B, A]>
) => T.EIO<EA | EB, B>;
/**
 * Atomically writes the specified value to the `XRef`, returning the value
 * immediately before modification.
 */
export declare const getAndSet: <A>(a: A) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.IO<A> | T.EIO<EA | EB, A>;
/**
 * Atomically writes the specified value to the `XRef`, returning the value
 * immediately before modification.
 */
export declare const getAndSet_: <EA, EB, A>(self: XRef<EA, EB, A, A>, a: A) => T.IO<A> | T.EIO<EA | EB, A>;
/**
 * Atomically modifies the `XRef` with the specified function, returning
 * the value immediately before modification.
 */
export declare const getAndUpdate: <A>(
   f: (a: A) => A
) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.IO<A> | T.EIO<EA | EB, A>;
/**
 * Atomically modifies the `XRef` with the specified function, returning
 * the value immediately before modification.
 */
export declare const getAndUpdate_: <EA, EB, A>(
   self: XRef<EA, EB, A, A>,
   f: (a: A) => A
) => T.IO<A> | T.EIO<EA | EB, A>;
/**
 * Atomically modifies the `XRef` with the specified partial function,
 * returning the value immediately before modification. If the function is
 * undefined on the current value it doesn't change it.
 */
export declare const getAndUpdateSome: <A>(
   f: (a: A) => Option<A>
) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.IO<A> | T.EIO<EA | EB, A>;
/**
 * Atomically modifies the `XRef` with the specified partial function,
 * returning the value immediately before modification. If the function is
 * undefined on the current value it doesn't change it.
 */
export declare const getAndUpdateSome_: <EA, EB, A>(
   self: XRef<EA, EB, A, A>,
   f: (a: A) => Option<A>
) => T.IO<A> | T.EIO<EA | EB, A>;
/**
 * Atomically modifies the `XRef` with the specified function.
 */
export declare const update: <A>(f: (a: A) => A) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.EIO<EA | EB, void>;
/**
 * Atomically modifies the `XRef` with the specified function.
 */
export declare const update_: <EA, EB, A>(self: XRef<EA, EB, A, A>, f: (a: A) => A) => T.EIO<EA | EB, void>;
/**
 * Atomically modifies the `XRef` with the specified function and returns
 * the updated value.
 */
export declare const updateAndGet: <A>(f: (a: A) => A) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.EIO<EA | EB, A>;
/**
 * Atomically modifies the `XRef` with the specified function and returns
 * the updated value.
 */
export declare const updateAndGet_: <EA, EB, A>(self: XRef<EA, EB, A, A>, f: (a: A) => A) => T.EIO<EA | EB, A>;
/**
 * Atomically modifies the `XRef` with the specified partial function. If
 * the function is undefined on the current value it doesn't change it.
 */
export declare const updateSome: <A>(
   f: (a: A) => Option<A>
) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.EIO<EA | EB, void>;
/**
 * Atomically modifies the `XRef` with the specified partial function. If
 * the function is undefined on the current value it doesn't change it.
 */
export declare const updateSome_: <EA, EB, A>(self: XRef<EA, EB, A, A>, f: (a: A) => Option<A>) => T.EIO<EA | EB, void>;
/**
 * Atomically modifies the `XRef` with the specified partial function. If
 * the function is undefined on the current value it returns the old value
 * without changing it.
 */
export declare const updateSomeAndGet: <A>(
   f: (a: A) => Option<A>
) => <EA, EB>(self: XRef<EA, EB, A, A>) => T.EIO<EA | EB, A>;
/**
 * Atomically modifies the `XRef` with the specified partial function. If
 * the function is undefined on the current value it returns the old value
 * without changing it.
 */
export declare const updateSomeAndGet_: <EA, EB, A>(
   self: XRef<EA, EB, A, A>,
   f: (a: A) => Option<A>
) => T.EIO<EA | EB, A>;
/**
 * Unsafe update value in a Ref<A>
 */
export declare const unsafeUpdate: <A>(f: (a: A) => A) => (self: Ref<A>) => void;
/**
 * Unsafe update value in a Ref<A>
 */
export declare const unsafeUpdate_: <A>(self: Ref<A>, f: (a: A) => A) => void;
/**
 * Reads the value from the `XRef`.
 */
export declare const get: <EA, EB, A, B>(self: XRef<EA, EB, A, B>) => T.EIO<EB, B>;
/**
 * Writes a new value to the `XRef`, with a guarantee of immediate
 * consistency (at some cost to performance).
 */
export declare const set: <A>(a: A) => <EA, EB, B>(self: XRef<EA, EB, A, B>) => T.EIO<EA, void>;
/**
 * Writes a new value to the `XRef`, with a guarantee of immediate
 * consistency (at some cost to performance).
 */
export declare const set_: <EA, EB, B, A>(self: XRef<EA, EB, A, B>, a: A) => T.EIO<EA, void>;
//# sourceMappingURL=combinators.d.ts.map