@typed/fx 1.32.0 → 2.0.0-beta.0

package/dist/dts/RefSubject.d.ts

@@ -1,601 +0,0 @@
-/**
- * A RefSubject is a Subject that can be used to read and write a value.
- * @since 1.20.0
- */
-import * as C from "@typed/context";
-import type { Tracer } from "effect";
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import type * as Equivalence from "effect/Equivalence";
-import * as ExecutionStrategy from "effect/ExecutionStrategy";
-import * as Exit from "effect/Exit";
-import type * as FiberId from "effect/FiberId";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import type * as Runtime from "effect/Runtime";
-import * as Scope from "effect/Scope";
-import { type Fx } from "./Fx.js";
-import type { UnionToTuple } from "./internal/UnionToTuple.js";
-import * as Subject from "./Subject.js";
-import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId } from "./TypeId.js";
-import * as Versioned from "./Versioned.js";
-/**
- * A Computed is essentially a readonly RefSubject.
- * @since 1.20.0
- */
-export interface Computed<out A, out E = never, out R = never> extends Versioned.Versioned<R, E, A, E, R | Scope.Scope, A, E, R> {
-    readonly [ComputedTypeId]: ComputedTypeId;
-    /**
-     * @since 1.25.0
-     */
-    readonly unsafeGet: () => Exit.Exit<A, E>;
-}
-/**
- * @since 1.20.0
- */
-export declare namespace Computed {
-    /**
-     * @since 1.20.0
-     */
-    type Any = Computed<any, any, any> | Computed<never, any, any> | Computed<any, never, any> | Computed<never, never, any>;
-}
-/**
- * A Filtered is essentially a readonly RefSubject that may have its values filtered out.
- * @since 1.20.0
- */
-export interface Filtered<out A, out E = never, out R = never> extends Versioned.Versioned<R, E, A, E, R | Scope.Scope, A, E | Cause.NoSuchElementException, R> {
-    readonly [FilteredTypeId]: FilteredTypeId;
-    /**
-     * @since 1.20.0
-     */
-    asComputed(): Computed<Option.Option<A>, E, R>;
-    /**
-     * @since 1.25.0
-     */
-    readonly unsafeGet: () => Exit.Exit<A, E | Cause.NoSuchElementException>;
-}
-/**
- * @since 1.20.0
- */
-export declare namespace Filtered {
-    /**
-     * @since 1.20.0
-     */
-    type Any = Filtered<any, any, any> | Filtered<never, any, any> | Filtered<any, never, any> | Filtered<never, never, any>;
-}
-/**
- * A RefSubject is a Subject that can be used to read and write a value.
- * @since 1.20.0
- */
-export interface RefSubject<in out A, in out E = never, out R = never> extends Computed<A, E, R>, Subject.Subject<A, E, R> {
-    readonly [RefSubjectTypeId]: RefSubjectTypeId;
-    /**
-     * @since 1.20.0
-     */
-    readonly runUpdates: <B, E2, R2>(f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>) => Effect.Effect<B, E2, R | R2>;
-    /**
-     * @since 1.25.0
-     */
-    readonly unsafeGet: () => Exit.Exit<A, E>;
-}
-/**
- * @since 1.20.0
- */
-export declare namespace RefSubject {
-    /**
-     * @since 1.20.0
-     */
-    type Any = RefSubject<any, any, any> | RefSubject<any, any> | RefSubject<any, never, any> | RefSubject<any>;
-    /**
-     * @since 1.20.0
-     */
-    interface Tagged<I, E, A> extends RefSubject<A, E, I> {
-        /**
-         * @since 1.20.0
-         */
-        readonly tag: C.Tagged<I, RefSubject<A, E>>;
-        /**
-         * @since 1.20.0
-         */
-        readonly make: <R>(fxOrEffect: Fx<A, E, R | Scope.Scope> | Effect.Effect<A, E, R | Scope.Scope>, options?: RefSubjectOptions<A> & {
-            readonly drop?: number;
-            readonly take?: number;
-        }) => Layer.Layer<I, never, R>;
-        /**
-         * @since 2.0.0
-         */
-        readonly layer: <E2, R2>(make: Effect.Effect<RefSubject<A, E>, E2, R2 | Scope.Scope>) => Layer.Layer<I, E2, R2>;
-    }
-    /**
-     * A Contextual wrapper around a RefSubject
-     * @since 1.18.0
-     * @category models
-     */
-    interface Derived<A, E, R> extends RefSubject<A, E, R> {
-        readonly persist: Effect.Effect<void, never, R>;
-    }
-    /**
-     * @since 1.20.0
-     */
-    type Context<T> = T extends RefSubject<infer _A, infer _E, infer R> ? R : T extends Computed<infer _A, infer _E, infer R> ? R : T extends Filtered<infer _A, infer _E, infer R> ? R : never;
-    /**
-     * @since 1.20.0
-     */
-    type Error<T> = T extends RefSubject<infer _A, infer E, infer _R> ? E : T extends Computed<infer _A, infer E, infer _R> ? E : T extends Filtered<infer _A, infer E, infer _R> ? E : never;
-    /**
-     * @since 1.20.0
-     */
-    type Success<T> = T extends RefSubject<infer A, infer _E, infer _R> ? A : T extends Computed<infer A, infer _E, infer _R> ? A : T extends Filtered<infer A, infer _E, infer _R> ? A : never;
-    /**
-     * @since 1.20.0
-     */
-    type Identifier<T> = T extends RefSubject.Tagged<infer R, infer _E, infer _A> ? R : never;
-}
-/**
- * @since 1.20.0
- */
-export type Context<T> = RefSubject.Context<T>;
-/**
- * @since 1.20.0
- */
-export type Error<T> = RefSubject.Error<T>;
-/**
- * @since 1.20.0
- */
-export type Success<T> = RefSubject.Success<T>;
-/**
- * @since 1.20.0
- */
-export type Identifier<T> = RefSubject.Identifier<T>;
-/**
- * @since 1.20.0
- */
-export interface RefSubjectOptions<A> {
-    readonly eq?: Equivalence.Equivalence<A>;
-    readonly executionStrategy?: ExecutionStrategy.ExecutionStrategy;
-}
-/**
- * @since 1.20.0
- */
-export declare function fromEffect<A, E, R>(effect: Effect.Effect<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
-/**
- * @since 1.20.0
- */
-export declare function fromFx<A, E, R>(fx: Fx<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
-/**
- * @since 1.20.0
- */
-export declare function fromRefSubject<A, E, R>(ref: RefSubject<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject.Derived<A, E, R>, never, R | Scope.Scope>;
-/**
- * @since 1.20.0
- */
-export declare const make: {
-    <A, E = never, R = never>(ref: RefSubject<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject.Derived<A, E, R>, never, R | Scope.Scope>;
-    <A, E = never, R = never>(fxOrEffect: Fx<A, E, R> | Effect.Effect<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, R | Scope.Scope>;
-    <A, E = never, R = never>(fxOrEffect: Fx<A, E, R> | Effect.Effect<A, E, R> | RefSubject<A, E, R>, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E> | RefSubject.Derived<A, E, R>, never, R | Scope.Scope>;
-};
-/**
- * @since 1.20.0
- */
-export declare function of<A, E = never>(a: A, options?: RefSubjectOptions<A>): Effect.Effect<RefSubject<A, E>, never, Scope.Scope>;
-/**
- * @since 1.20.0
- */
-export declare function unsafeMake<E, A>(params: {
-    readonly id: FiberId.FiberId;
-    readonly initial: Effect.Effect<A, E>;
-    readonly options?: RefSubjectOptions<A> | undefined;
-    readonly scope: Scope.CloseableScope;
-    readonly initialValue?: A;
-}): Effect.Effect<RefSubject<A, E>>;
-/**
- * @since 1.20.0
- */
-export declare const set: {
-    <A>(value: A): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E, R>;
-    <A, E, R>(ref: RefSubject<A, E, R>, a: A): Effect.Effect<A, E, R>;
-};
-/**
- * @since 1.20.0
- */
-export declare function reset<A, E, R>(ref: RefSubject<A, E, R>): Effect.Effect<Option.Option<A>, E, R>;
-/**
- * @since 1.20.0
- */
-export { 
-/**
- * @since 1.20.0
- */
-reset as delete };
-/**
- * @since 1.20.0
- */
-export interface GetSetDelete<A, E, R> {
-    /**
-     * @since 1.20.0
-     */
-    readonly get: Effect.Effect<A, E, R>;
-    /**
-     * @since 1.20.0
-     */
-    readonly set: (a: A) => Effect.Effect<A, never, R>;
-    /**
-     * @since 1.20.0
-     */
-    readonly delete: Effect.Effect<Option.Option<A>, E, R>;
-}
-/**
- * @since 1.20.0
- */
-export declare const updateEffect: {
-    <A, E2, R2>(f: (value: A) => Effect.Effect<A, E2, R2>): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E | E2, R | R2>;
-    <A, E, R, E2, R2>(ref: RefSubject<A, E, R>, f: (value: A) => Effect.Effect<A, E2, R2>): Effect.Effect<A, E | E2, R | R2>;
-};
-/**
- * @since 1.20.0
- */
-export declare const update: {
-    <A>(f: (value: A) => A): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E, R>;
-    <A, E, R>(ref: RefSubject<A, E, R>, f: (value: A) => A): Effect.Effect<A, E, R>;
-};
-/**
- * @since 1.20.0
- */
-export declare const modifyEffect: {
-    <A, B, E2, R2>(f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<B, E | E2, R | R2>;
-    <A, E, R, B, E2, R2>(ref: RefSubject<A, E, R>, f: (value: A) => Effect.Effect<readonly [B, A], E2, R2>): Effect.Effect<B, E | E2, R | R2>;
-};
-/**
- * @since 1.20.0
- */
-export declare const modify: {
-    <A, B>(f: (value: A) => readonly [B, A]): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<B, E, R>;
-    <A, E, R, B>(ref: RefSubject<A, E, R>, f: (value: A) => readonly [B, A]): Effect.Effect<B, E, R>;
-};
-/**
- * @since 1.20.0
- */
-export declare const runUpdates: {
-    <A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>, options?: {
-        readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
-        readonly value?: "initial" | "current";
-    } | undefined): (ref: RefSubject<A, E, R>) => Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
-    <A, E, R, B, E2, R2, R3 = never, E3 = never, C = never>(ref: RefSubject<A, E, R>, f: (ref: GetSetDelete<A, E, R>) => Effect.Effect<B, E2, R2>, options?: {
-        readonly onInterrupt: (value: A) => Effect.Effect<C, E3, R3>;
-        readonly value?: "initial" | "current";
-    } | undefined): Effect.Effect<B, E | E2 | E3, R | R2 | R3>;
-};
-/**
- * @since 1.20.0
- */
-export declare const mapEffect: {
-    <T extends RefSubject.Any | Computed.Any | Filtered.Any, B, E2, R2>(f: (a: Success<T>) => Effect.Effect<B, E2, R2>): (ref: T) => T extends Filtered.Any ? Filtered<B, Error<T> | E2, Context<T> | R2> : Computed<B, Error<T> | E2, Context<T> | R2>;
-    <A, E, R, B, E2, R2>(ref: RefSubject<A, E, R> | Computed<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Computed<B, E | E2, R | R2>;
-    <A, E, R, B, E2, R2>(ref: Filtered<A, E, R>, f: (a: A) => Effect.Effect<B, E2, R2>): Filtered<B, E | E2, R | R2>;
-    <R0, E0, A, E, R, E2, R2, C, E3, R3>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<C, E3, R3>): Computed<C, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
-};
-/**
- * @since 1.20.0
- */
-export declare const map: {
-    <T extends RefSubject.Any | Computed.Any | Filtered.Any, B>(f: (a: Success<T>) => B): (ref: T) => T extends Filtered.Any ? Filtered<B, Error<T>, Context<T>> : Computed<B, Error<T>, Context<T>>;
-    <A, E, R, B>(ref: RefSubject<A, E, R> | Computed<A, E, R>, f: (a: A) => B): Computed<B, E, R>;
-    <A, E, R, B>(filtered: Filtered<A, E, R>, f: (a: A) => B): Filtered<B, E, R>;
-    <R0, E0, A, E, R, B, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => B): Computed<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>> | Filtered<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>>;
-};
-/**
- * @since 1.20.0
- */
-export declare const filterMapEffect: {
-    <A, B, E2, R2>(f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): {
-        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>): Filtered<B, E | E2, R | R2>;
-        <E, R>(ref: Filtered<A, E, R>): Filtered<B, E | E2, R | R2>;
-        <R0, E0, B, E, R, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): Filtered<B, E0 | E | E2, R0 | R2>;
-    };
-    <A, E, R, B, E2, R2>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, f: (a: A) => Effect.Effect<Option.Option<B>, E2, R2>): Filtered<B, E | E2, R | R2>;
-    <R0, E0, A, E, R, B, E2, R2, R3, E3>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<Option.Option<B>, E3, R3>): Filtered<B, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
-};
-/**
- * @since 1.20.0
- */
-export declare const filterMap: {
-    <A, B>(f: (a: A) => Option.Option<B>): {
-        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>): Filtered<B, E, R>;
-        <R0, E0, B, E, R, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Option.Option<B>): Filtered<B, E0 | E | E2, R0 | R2>;
-    };
-    <R0, E0, A, E, R, B, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Option.Option<B>): Filtered<B, E0 | E | E2, R0 | R2 | Exclude<R, Scope.Scope>>;
-    <A, E, R, B>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, f: (a: A) => Option.Option<B>): Filtered<B, E, R>;
-};
-/**
- * @since 1.20.0
- */
-export declare const compact: {
-    <A, E, R>(ref: Computed<Option.Option<A>, E, R>): Filtered<A>;
-    <A, E, R>(ref: Filtered<Option.Option<A>, E, R>): Filtered<A>;
-    <R0, E0, A, E, R, E2, R2>(versioned: Versioned.Versioned<R0, E0, Option.Option<A>, E, R, Option.Option<A>, E2, R2>): Filtered<A, E0 | E | Exclude<E, Cause.NoSuchElementException> | Exclude<E2, Cause.NoSuchElementException>, R0 | R2 | Exclude<R, Scope.Scope>>;
-};
-/**
- * @since 1.20.0
- */
-export declare const filterEffect: {
-    <A, E, R, E2, R2>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, f: (a: A) => Effect.Effect<boolean, E2, R2>): Filtered<A, E | E2, R | R2>;
-    <R0, E0, A, E, R, E2, R2, R3, E3>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => Effect.Effect<boolean, E3, R3>): Filtered<A, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
-};
-/**
- * @since 1.20.0
- */
-export declare const filter: {
-    <A>(f: (a: A) => boolean): {
-        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>): Filtered<A, E, R>;
-        <R0, E0, R, E, E2, R2>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => boolean): Filtered<A, E0 | E | E2, R0 | R2>;
-    };
-    <A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, f: (a: A) => boolean): Filtered<A, E, R>;
-    <R0, E0, A, E, R, E2, R2, R3, E3>(versioned: Versioned.Versioned<R0, E0, A, E, R, A, E2, R2>, f: (a: A) => boolean): Filtered<A, E0 | E | E2 | E3, R0 | R2 | R3 | Exclude<R, Scope.Scope>>;
-};
-/**
- * @since 1.20.0
- */
-export declare const skipRepeatsWith: {
-    <A>(eq: Equivalence.Equivalence<A>): {
-        <E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>): Computed<A, E, R>;
-        <E, R>(ref: Filtered<A, E, R>): Filtered<A, E, R>;
-    };
-    <A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>, eq: Equivalence.Equivalence<A>): Computed<A, E, R>;
-    <A, E, R>(ref: Filtered<A, E, R>, eq: Equivalence.Equivalence<A>): Filtered<A, E, R>;
-    <A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>, eq: Equivalence.Equivalence<A>): Computed<A, E, R> | Filtered<A, E, R>;
-};
-/**
- * @since 1.20.0
- */
-export declare function skipRepeats<A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R>): Computed<A, E, R>;
-export declare function skipRepeats<A, E, R>(ref: Filtered<A, E, R>): Filtered<A, E, R>;
-export declare function skipRepeats<A, E, R>(ref: RefSubject<A, E, R> | Computed<A, E, R> | Filtered<A, E, R>): Computed<A, E, R> | Filtered<A, E, R>;
-/**
- * @since 1.20.0
- */
-export declare function transform<A, E, R, B>(ref: RefSubject<A, E, R>, from: (a: A) => B, to: (b: B) => A): RefSubject<B, E, R>;
-/**
- * @since 1.20.0
- */
-export declare function transformOrFail<R, E, A, E2, R2, R3, E3, B>(ref: RefSubject<A, E, R>, from: (a: A) => Effect.Effect<B, E2, R2>, to: (b: B) => Effect.Effect<A, E3, R3>): RefSubject<B, E | E2 | E3, R | R2 | R3>;
-/**
- * @since 1.20.0
- */
-export declare function tuple<const Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>>(refs: Refs): TupleFrom<Refs>;
-type RefKind = "r" | "c" | "f";
-/**
- * @since 1.20.0
- */
-export type TupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = {
-    "c": [ComputedTupleFrom<Refs>] extends [Computed<infer A, infer E, infer R>] ? Computed<A, E, R> : never;
-    "f": [FilteredTupleFrom<Refs>] extends [Filtered<infer A, infer E, infer R>] ? Filtered<A, E, R> : never;
-    "r": [RefSubjectTupleFrom<Refs>] extends [RefSubject<infer A, infer E, infer R>] ? RefSubject<A, E, R> : never;
-}[GetTupleKind<Refs>];
-type Ref = RefSubject.Any | Computed.Any | Filtered.Any;
-/**
- * @since 1.20.0
- */
-export type GetTupleKind<Refs extends ReadonlyArray<Ref>, Kind extends RefKind = "r"> = Refs extends readonly [infer Head extends Ref, ...infer Tail extends ReadonlyArray<Ref>] ? GetTupleKind<Tail, MergeKind<Kind, MatchKind<Head>>> : Kind;
-/**
- * @since 1.20.0
- */
-export type MatchKind<T extends Ref> = [T] extends [Filtered.Any] ? "f" : [T] extends [RefSubject.Any] ? "r" : "c";
-type MergeKind<A extends RefKind, B extends RefKind> = A extends "f" ? A : B extends "f" ? B : A extends "r" ? B : B extends "r" ? A : "c";
-type FilteredTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = Filtered<{
-    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
-}, Fx.Error<Refs[number]>, Effect.Effect.Context<Refs[number]>>;
-type ComputedTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = Computed<{
-    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
-}, Effect.Effect.Error<Refs[number]>, Effect.Effect.Context<Refs[number]>>;
-type RefSubjectTupleFrom<Refs extends ReadonlyArray<RefSubject<any, any, any> | Computed<any, any, any> | Filtered<any, any, any>>> = RefSubject<{
-    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
-}, Effect.Effect.Error<Refs[number]>, Effect.Effect.Context<Refs[number]>>;
-/**
- * @since 1.20.0
- */
-export declare function struct<const Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>>(refs: Refs): StructFrom<Refs>;
-type StructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = {
-    "c": [ComputedStructFrom<Refs>] extends [Computed<infer A, infer E, infer R>] ? Computed<A, E, R> : never;
-    "f": [FilteredStructFrom<Refs>] extends [Filtered<infer A, infer E, infer R>] ? Filtered<A, E, R> : never;
-    "r": [RefSubjectStructFrom<Refs>] extends [RefSubject<infer A, infer E, infer R>] ? RefSubject<A, E, R> : never;
-}[GetStructKind<Refs>];
-/**
- * @since 1.20.0
- */
-export type GetStructKind<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = MergeKinds<UnionToTuple<{
-    [K in keyof Refs]: MatchKind<Refs[K]>;
-}[keyof Refs]>>;
-type MergeKinds<Kinds extends ReadonlyArray<any>> = Kinds extends readonly [infer Head extends RefKind, ...infer Tail extends ReadonlyArray<RefKind>] ? MergeKind<Head, MergeKinds<Tail>> : "r";
-type FilteredStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = Filtered<{
-    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
-}, Fx.Error<Refs[keyof Refs]>, Effect.Effect.Context<Refs[keyof Refs]>>;
-type ComputedStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = Computed<{
-    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
-}, Effect.Effect.Error<Refs[keyof Refs]>, Effect.Effect.Context<Refs[keyof Refs]>>;
-type RefSubjectStructFrom<Refs extends Readonly<Record<string, RefSubject.Any | Computed.Any | Filtered.Any>>> = RefSubject<{
-    readonly [K in keyof Refs]: Effect.Effect.Success<Refs[K]>;
-}, Effect.Effect.Error<Refs[keyof Refs]>, Effect.Effect.Context<Refs[keyof Refs]>>;
-/**
- * @since 1.20.0
- */
-export declare function tagged<A, E = never>(replay?: number): {
-    <const I extends C.IdentifierFactory<any>>(identifier: I): RefSubject.Tagged<C.IdentifierOf<I>, E, A>;
-    <const I>(identifier: I): RefSubject.Tagged<C.IdentifierOf<I>, E, A>;
-};
-/**
- * @since 1.20.0
- */
-export declare function fromTag<I, S, A, E, R>(tag: C.Tag<I, S>, f: (s: S) => RefSubject<A, E, R>): RefSubject<A, E, I | R>;
-/**
- * @since 1.20.0
- */
-export declare function isRefSubject<A, E, R>(u: unknown): u is RefSubject<A, E, R>;
-export declare function isRefSubject(u: unknown): u is RefSubject.Any;
-/**
- * @since 1.20.0
- */
-export declare function isComputed<A, E, R>(u: unknown): u is Computed<A, E, R>;
-export declare function isComputed(u: unknown): u is Computed.Any;
-/**
- * @since 1.20.0
- */
-export declare function isFiltered<A, E, R>(u: unknown): u is Filtered<A, E, R>;
-export declare function isFiltered(u: unknown): u is Filtered.Any;
-/**
- * @since 1.20.0
- */
-export declare function isDerived<A, E, R>(u: unknown): u is RefSubject.Derived<A, E, R>;
-export declare function isDerived(u: unknown): u is RefSubject.Derived<unknown, unknown, unknown>;
-/**
- * @since 1.20.0
- */
-export declare function computedFromTag<I, S, A, E, R>(tag: C.Tag<I, S>, f: (s: S) => Computed<A, E, R>): Computed<A, E, I | R>;
-/**
- * @since 1.20.0
- */
-export declare function filteredFromTag<I, S, A, E, R>(tag: C.Tag<I, S>, f: (s: S) => Filtered<A, E, R>): Filtered<A, E, R | I>;
-/**
- * @since 1.20.0
- */
-export declare const provide: {
-    <S>(context: C.Context<S> | Runtime.Runtime<S>): {
-        <A, E, R>(filtered: Filtered<A, E, R>): Filtered<A, E, Exclude<R, S>>;
-        <A, E, R>(computed: Computed<A, E, R>): Computed<A, E, Exclude<R, S>>;
-        <A, E, R>(ref: RefSubject<A, E, R>): RefSubject<A, E, Exclude<R, S>>;
-    };
-    <R2, S>(layer: Layer.Layer<S, never, R2>): {
-        <A, E, R>(filtered: Filtered<A, E, R>): Filtered<A, E, Exclude<R, S> | R2>;
-        <A, E, R>(computed: Computed<A, E, R>): Computed<A, E, Exclude<R, S> | R2>;
-        <A, E, R>(ref: RefSubject<A, E, R>): RefSubject<A, E, Exclude<R, S> | R2>;
-    };
-    <A, E, R, S>(filtered: Filtered<A, E, R>, context: C.Context<S> | Runtime.Runtime<S>): Filtered<A, E, Exclude<R, S>>;
-    <A, E, R, S>(computed: Computed<A, E, R>, context: C.Context<S> | Runtime.Runtime<S>): Computed<A, E, Exclude<R, S>>;
-    <A, E, R, S>(ref: RefSubject<A, E, R>, context: C.Context<S> | Runtime.Runtime<S>): RefSubject<A, E, Exclude<R, S>>;
-    <A, E, R, R2, S>(filtered: Filtered<A, E, R>, layer: Layer.Layer<S, never, R2>): Filtered<A, E, Exclude<R, S> | R2>;
-    <A, E, R, R2, S>(computed: Computed<A, E, R>, layer: Layer.Layer<S, never, R2>): Computed<A, E, Exclude<R, S> | R2>;
-    <A, E, R, R2, S>(ref: RefSubject<A, E, R>, layer: Layer.Layer<S, never, R2>): RefSubject<A, E, Exclude<R, S> | R2>;
-};
-/**
- * Set the value to true
- * @since 1.18.0
- */
-export declare const asTrue: <E, R>(ref: RefSubject<boolean, E, R>) => Effect.Effect<boolean, E, R>;
-/**
- * Set the value to false
- * @since 1.18.0
- */
-export declare const asFalse: <E, R>(ref: RefSubject<boolean, E, R>) => Effect.Effect<boolean, E, R>;
-/**
- * Toggle the boolean value between true and false
- * @since 1.18.0
- */
-export declare const toggle: <E, R>(ref: RefSubject<boolean, E, R>) => Effect.Effect<boolean, E, R>;
-/**
- * Set the value to true
- * @since 1.18.0
- */
-export declare const increment: <E, R>(ref: RefSubject<number, E, R>) => Effect.Effect<number, E, R>;
-/**
- * Set the value to false
- * @since 1.18.0
- */
-export declare const decrement: <E, R>(ref: RefSubject<number, E, R>) => Effect.Effect<number, E, R>;
-/**
- * @since 1.20.0
- */
-export declare const slice: {
-    (drop: number, take: number): <A, E, R>(ref: RefSubject<A, E, R>) => RefSubject<A, E, R>;
-    <A, E, R>(ref: RefSubject<A, E, R>, drop: number, take: number): RefSubject<A, E, R>;
-};
-/**
- * @since 1.20.0
- */
-export declare const drop: {
-    (drop: number): <A, E, R>(ref: RefSubject<A, E, R>) => RefSubject<A, E, R>;
-    <A, E, R>(ref: RefSubject<A, E, R>, drop: number): RefSubject<A, E, R>;
-};
-/**
- * @since 1.20.0
- */
-export declare const take: {
-    (take: number): <A, E, R>(ref: RefSubject<A, E, R>) => RefSubject<A, E, R>;
-    <A, E, R>(ref: RefSubject<A, E, R>, take: number): RefSubject<A, E, R>;
-};
-/**
- * Get the current value of the RefSubject. If it has not been set yet, a Fiber will be used to wait for the value to be set.
- *
- * @since 1.25.0
- */
-export declare const get: {
-    <A, E = never, R = never>(ref: RefSubject<A, E, R>): Effect.Effect<A, E, R>;
-    <A, E = never, R = never>(ref: Computed<A, E, R>): Effect.Effect<A, E, R>;
-    <A, E = never, R = never>(ref: Filtered<A, E, R>): Effect.Effect<A, E | Cause.NoSuchElementException, R>;
-};
-/**
- * Synchronously get the current Exit value of the RefSubject. If it has not been set yet, a Cause.NoSuchElementException will be thrown.
- *
- * Note: This is unimplemented for RefSubject.tagged and RefSubject.fromTag because they require the Effect context by definition.
- * It will throw immediately.
- *
- * @since 1.25.0
- */
-export declare const unsafeGetExit: <A, E = never, R = never>(ref: RefSubject<A, E, R>) => Exit.Exit<A, E>;
-/**
- * Synchronously get the current value of the RefSubject.
- *
- * @since 1.25.0
- */
-export declare const unsafeGet: <A, E = never, R = never>(ref: RefSubject<A, E, R>) => A;
-/**
- * Extract all values from an object using a Proxy
- *
- * @since 2.0.0
- */
-export declare const proxy: {
-    <A extends ReadonlyArray<any> | Readonly<Record<PropertyKey, any>>, E, R>(source: Computed<A, E, R>): {
-        readonly [K in keyof A]: Computed<A[K], E, R>;
-    };
-    <A extends ReadonlyArray<any> | Readonly<Record<PropertyKey, any>>, E, R>(source: Filtered<A, E, R>): {
-        readonly [K in keyof A]: Filtered<A[K], E, R>;
-    };
-};
-/**
- * @since 2.0.0
- */
-export declare const withSpan: {
-    (name: string, options?: {
-        readonly attributes?: Record<string, unknown>;
-        readonly links?: ReadonlyArray<Tracer.SpanLink>;
-        readonly parent?: Tracer.ParentSpan;
-        readonly root?: boolean;
-        readonly context?: C.Context<never>;
-    }): <A, E, R>(self: RefSubject<A, E, R>) => RefSubject<A, E, R>;
-    <A, E, R>(self: RefSubject<A, E, R>, name: string, options?: {
-        readonly attributes?: Record<string, unknown>;
-        readonly links?: ReadonlyArray<Tracer.SpanLink>;
-        readonly parent?: Tracer.ParentSpan;
-        readonly root?: boolean;
-        readonly context?: C.Context<never>;
-    }): RefSubject<A, E, R>;
-};
-/**
- * @since 2.0.0
- */
-export declare const when: {
-    <B, C>(options: {
-        onTrue: B;
-        onFalse: C;
-    }): {
-        <E, R>(ref: Filtered<boolean, E, R>): Filtered<B | C, E, R>;
-        <E, R>(ref: Computed<boolean, E, R>): Computed<B | C, E, R>;
-    };
-    <E, R, B, C>(ref: Filtered<boolean, E, R>, options: {
-        onTrue: B;
-        onFalse: C;
-    }): Filtered<B | C, E, R>;
-    <E, R, B, C>(ref: Computed<boolean, E, R>, options: {
-        onTrue: B;
-        onFalse: C;
-    }): Computed<B | C, E, R>;
-};
-//# sourceMappingURL=RefSubject.d.ts.map