import * as E from "../../Either";
import type { AtomicReference } from "../../support";
import * as T from "../Task/_core";
import type { EIO, IO } from "../Task/model";
export interface XRef<EA, EB, A, B> {
   /**
    * Folds over the error and value types of the `XRef`. This is a highly
    * polymorphic method that is capable of arbitrarily transforming the error
    * and value types of the `XRef`. For most use cases one of the more specific
    * combinators implemented in terms of `fold` will be more ergonomic but this
    * method is extremely useful for implementing new combinators.
    */
   readonly fold: <EC, ED, C, D>(
      ea: (_: EA) => EC,
      eb: (_: EB) => ED,
      ca: (_: C) => E.Either<EC, A>,
      bd: (_: B) => E.Either<ED, D>
   ) => XRef<EC, ED, C, D>;
   /**
    * Folds over the error and value types ofthe `XRef`, allowing access to
    * the state in transforming the `set` value. This is a more powerful version
    * of `fold` but requires unifying the error types.
    */
   readonly foldAll: <EC, ED, C, D>(
      ea: (_: EA) => EC,
      eb: (_: EB) => ED,
      ec: (_: EB) => EC,
      ca: (_: C) => (_: B) => E.Either<EC, A>,
      bd: (_: B) => E.Either<ED, D>
   ) => XRef<EC, ED, C, D>;
   /**
    * Reads the value from the `XRef`.
    */
   readonly get: EIO<EB, B>;
   /**
    * Writes a new value to the `XRef`, with a guarantee of immediate
    * consistency (at some cost to performance).
    */
   readonly set: (a: A) => EIO<EA, void>;
}
export declare class DerivedAll<EA, EB, A, B, S> implements XRef<EA, EB, A, B> {
   readonly value: Atomic<S>;
   readonly getEither: (s: S) => E.Either<EB, B>;
   readonly setEither: (a: A) => (s: S) => E.Either<EA, S>;
   readonly _tag = "DerivedAll";
   constructor(value: Atomic<S>, getEither: (s: S) => E.Either<EB, B>, setEither: (a: A) => (s: S) => E.Either<EA, S>);
   readonly fold: <EC, ED, C, D>(
      ea: (_: EA) => EC,
      eb: (_: EB) => ED,
      ca: (_: C) => E.Either<EC, A>,
      bd: (_: B) => E.Either<ED, D>
   ) => XRef<EC, ED, C, D>;
   readonly foldAll: <EC, ED, C, D>(
      ea: (_: EA) => EC,
      eb: (_: EB) => ED,
      ec: (_: EB) => EC,
      ca: (_: C) => (_: B) => E.Either<EC, A>,
      bd: (_: B) => E.Either<ED, D>
   ) => XRef<EC, ED, C, D>;
   readonly get: EIO<EB, B>;
   readonly set: (a: A) => EIO<EA, void>;
}
export declare class Derived<EA, EB, A, B, S> implements XRef<EA, EB, A, B> {
   readonly value: Atomic<S>;
   readonly getEither: (s: S) => E.Either<EB, B>;
   readonly setEither: (a: A) => E.Either<EA, S>;
   readonly _tag = "Derived";
   constructor(value: Atomic<S>, getEither: (s: S) => E.Either<EB, B>, setEither: (a: A) => E.Either<EA, S>);
   readonly fold: <EC, ED, C, D>(
      ea: (_: EA) => EC,
      eb: (_: EB) => ED,
      ca: (_: C) => E.Either<EC, A>,
      bd: (_: B) => E.Either<ED, D>
   ) => XRef<EC, ED, C, D>;
   readonly foldAll: <EC, ED, C, D>(
      ea: (_: EA) => EC,
      eb: (_: EB) => ED,
      ec: (_: EB) => EC,
      ca: (_: C) => (_: B) => E.Either<EC, A>,
      bd: (_: B) => E.Either<ED, D>
   ) => XRef<EC, ED, C, D>;
   readonly get: EIO<EB, B>;
   readonly set: (a: A) => EIO<EA, void>;
}
export declare class Atomic<A> implements XRef<never, never, A, A> {
   readonly value: AtomicReference<A>;
   readonly _tag = "Atomic";
   readonly fold: <EC, ED, C, D>(
      _ea: (_: never) => EC,
      _eb: (_: never) => ED,
      ca: (_: C) => E.Either<EC, A>,
      bd: (_: A) => E.Either<ED, D>
   ) => XRef<EC, ED, C, D>;
   readonly foldAll: <EC, ED, C, D>(
      _ea: (_: never) => EC,
      _eb: (_: never) => ED,
      _ec: (_: never) => EC,
      ca: (_: C) => (_: A) => E.Either<EC, A>,
      bd: (_: A) => E.Either<ED, D>
   ) => XRef<EC, ED, C, D>;
   constructor(value: AtomicReference<A>);
   get get(): IO<A>;
   readonly set: (a: A) => T.IO<void>;
}
/**
 * A Ref that can fail with error E
 */
export interface ERef<E, A> extends XRef<E, E, A, A> {}
/**
 * A Ref that cannot fail
 */
export interface Ref<A> extends ERef<never, A> {}
/**
 * Cast to a sealed union in case of ERef (where it make sense)
 */
export declare const concrete: <EA, EB, A>(
   self: XRef<EA, EB, A, A>
) => Atomic<A> | DerivedAll<EA, EB, A, A, A> | Derived<EA, EB, A, A, A>;
//# sourceMappingURL=model.d.ts.map