@fncts/test 0.0.1

package/control/Gen/api.d.ts

@@ -0,0 +1,169 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { IO, URIO } from "@fncts/io/IO";
+import { Has } from "@fncts/base/typeclass";
+import { Stream } from "@fncts/io/Stream";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { NumberConstraints } from "./constraints.js";
+import type { _A, _R } from "@fncts/base/types.js";
+import { Sample } from "../Sample.js";
+import { Sized } from "../Sized.js";
+import { Gen } from "./definition.js";
+/**
+ * @tsplus static fncts.test.GenOps anyBigInt
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const anyBigInt: Gen<unknown, bigint>;
+/**
+ * @tsplus static fncts.test.GenOps anyDouble
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const anyDouble: Gen<unknown, number>;
+/**
+ * @tsplus static fncts.test.GenOps anyInt
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const anyInt: Gen<unknown, number>;
+/**
+ * @tsplus static fncts.test.GenOps bounded
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function bounded<R, A>(min: number, max: number, f: (n: number) => Gen<R, A>): Gen<R, A>;
+/**
+ * @tsplus static fncts.test.GenOps constant
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function constant<A>(a: A): Gen<unknown, A>;
+/**
+ * @tsplus fluent fncts.test.Gen flatMap
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function flatMap_<R, A, R1, B>(ma: Gen<R, A>, f: (a: A) => Gen<R1, B>): Gen<R & R1, B>;
+/**
+ * @tsplus static fncts.test.GenOps defer
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function defer<R, A>(gen: Lazy<Gen<R, A>>): Gen<R, A>;
+/**
+ * @tsplus static fncts.test.GenOps empty
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const empty: Gen<unknown, never>;
+/**
+ * @tsplus fluent fncts.test.Gen filter
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function filter_<R, A, B extends A>(fa: Gen<R, A>, p: Refinement<A, B>): Gen<R, B>;
+export declare function filter_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A>;
+/**
+ * @tsplus fluent fncts.test.Gen filterNot
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function filterNot_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A>;
+/**
+ * @tsplus getter fncts.test.Gen flatten
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function flatten<R, R1, A>(mma: Gen<R, Gen<R1, A>>): Gen<R & R1, A>;
+/**
+ * @tsplus static fncts.test.GenOps fromIO
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function fromIO<R, A>(effect: IO<R, never, A>): Gen<R, A>;
+/**
+ * @tsplus static fncts.test.GenOps fromIOSample
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function fromIOSample<R, A>(effect: IO<R, never, Sample<R, A>>): Gen<R, A>;
+/**
+ * @tsplus static fncts.test.GenOps int
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function int(constraints?: NumberConstraints): Gen<unknown, number>;
+/**
+ * @tsplus fluent fncts.test.Gen map
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function map_<R, A, B>(self: Gen<R, A>, f: (a: A) => B): Gen<R, B>;
+/**
+ * @tsplus fluent fncts.test.Gen mapIO
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never, B>): Gen<R & R1, B>;
+/**
+ * @tsplus static fncts.test.GenOps exponential
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const exponential: Gen<unknown, number>;
+/**
+ * @tsplus static fncts.test.GenOps size
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const size: Gen<Has<Sized>, number>;
+/**
+ * @tsplus static fncts.test.GenOps medium
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function medium<R, A>(f: (n: number) => Gen<R, A>, min?: number): Gen<R & Has<Sized>, A>;
+/**
+ * @tsplus static fncts.test.GenOps memo
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function memo<R, A>(builder: (maxDepth: number) => Gen<R, A>): (maxDepth?: number) => Gen<R, A>;
+/**
+ * @tsplus static fncts.test.GenOps nat
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function nat(max?: number): Gen<unknown, number>;
+/**
+ * @tsplus static fncts.test.GenOps oneOf
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A): Gen<_R<A[number]>, _A<A[number]>>;
+/**
+ * @tsplus fluent fncts.test.Gen reshrink
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B>): Gen<R & R1, B>;
+/**
+ * @tsplus static fncts.test.GenOps sized
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function sized<R, A>(f: (size: number) => Gen<R, A>): Gen<R & Has<Sized>, A>;
+/**
+ * @tsplus static fncts.test.GenOps small
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function small<R, A>(f: (size: number) => Gen<R, A>, min?: number): Gen<R & Has<Sized>, A>;
+/**
+ * @tsplus static fncts.test.GenOps unfoldGen
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function unfoldGen<S, R, A>(s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R & Has<Sized>, Conc<A>>;
+/**
+ * @tsplus static fncts.test.GenOps unfoldGenN
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function unfoldGenN<S, R, A>(n: number, s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R, Conc<A>>;
+/**
+ * @tsplus static fncts.test.GenOps uniform
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const uniform: Gen<unknown, number>;
+/**
+ * @tsplus static fncts.test.GenOps unwrap
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function unwrap<R, R1, A>(effect: URIO<R, Gen<R1, A>>): Gen<R & R1, A>;
+/**
+ * @tsplus static fncts.test.GenOps weighted
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function weighted<R, A>(...gens: ReadonlyArray<readonly [Gen<R, A>, number]>): Gen<R, A>;
+/**
+ * @tsplus fluent fncts.test.Gen zipWith
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function zipWith_<R, A, R1, B, C>(self: Gen<R, A>, that: Gen<R1, B>, f: (a: A, b: B) => C): Gen<R & R1, C>;

package/control/Gen/constraints.d.ts

@@ -0,0 +1,32 @@
+import type { Gen } from "./definition.js";
+import type { Eq } from "@fncts/base/typeclass";
+export interface LengthConstraints {
+    minLength?: number;
+    maxLength?: number;
+}
+export interface EqConstraint<A> {
+    eq?: Eq<A>;
+}
+export interface DateConstraints {
+    min?: Date;
+    max?: Date;
+}
+export interface ObjectConstraints {
+    maxDepth?: number;
+    maxKeys?: number;
+    key?: Gen<any, string>;
+    values?: Gen<any, any>[];
+    withSet?: boolean;
+    withMap?: boolean;
+    withBigint?: boolean;
+    withDate?: boolean;
+    withTypedArray?: boolean;
+}
+export interface NumberConstraints {
+    min?: number;
+    max?: number;
+}
+export interface FloatConstraints {
+    noDefaultInfinity?: boolean;
+    noNaN?: boolean;
+}

package/control/Gen/definition.d.ts

@@ -0,0 +1,11 @@
+import { Stream } from "@fncts/io/Stream";
+import { Maybe } from "@fncts/base/data/Maybe";
+import type { Sample } from "../Sample.js";
+/**
+ * @tsplus type fncts.test.Gen
+ * @tsplus companion fncts.test.GenOps
+ */
+export declare class Gen<R, A> {
+    readonly sample: Stream<R, never, Maybe<Sample<R, A>>>;
+    constructor(sample: Stream<R, never, Maybe<Sample<R, A>>>);
+}

package/control/Gen.d.ts

@@ -0,0 +1,10 @@
+export * from "./Gen/api.js";
+export * from "./Gen/constraints.js";
+export * from "./Gen/definition.js";
+export * from "./Gen/api/array.js";
+export * from "./Gen/api/char.js";
+export * from "./Gen/api/conc.js";
+export * from "./Gen/api/double.js";
+export * from "./Gen/api/float.js";
+export * from "./Gen/api/string.js";
+export * from "./Gen/api/struct.js";

package/control/Live/definition.d.ts

@@ -0,0 +1,24 @@
+import { IO } from "@fncts/io/IO";
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass";
+import type { Erase } from "@fncts/typelevel/Intersection";
+import { IOEnv } from "@fncts/io/IOEnv";
+/**
+ * @tsplus static fncts.test.LiveOps Tag
+ * @tsplus location "@fncts/test/control/Live/definition"
+ */
+export declare const LiveTag: import("@fncts/base/data/Tag").Tag<Live>;
+/**
+ * @tsplus companion fncts.test.LiveOps
+ */
+export declare abstract class Live {
+    abstract provide<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
+    static Default: Layer<IOEnv, never, Has<Live>>;
+    static Live<R extends Has<Live>, E, A>(io: IO<R, E, A>): IO<R & Has<Live>, E, A>;
+}
+/**
+ * @tsplus static fncts.test.LiveOps withLive
+ * @tsplus location "@fncts/test/control/Live/definition"
+ */
+export declare function withLive_<R, E, A, E1, B>(io: IO<R, E, A>, f: (_: IO<unknown, E, A>) => IO<IOEnv, E1, B>): IO<Erase<R, Has<Live>>, E | E1, B>;
+export declare function withLive<R extends Has<Live>, E, A>(io: IO<R, E, A>): <E1, B>(f: (_: IO<R, E, A>) => import("@fncts/io/IO").IO<R, E1, B>) => import("@fncts/io/IO").IO<R & import("@fncts/base/typeclass").Has<Live>, E1, B>;

package/control/Live.d.ts

@@ -0,0 +1 @@
+export * from "./Live/definition.js";

package/control/RunnableSpec.d.ts

@@ -0,0 +1,12 @@
+import { URIO } from "@fncts/io/IO";
+import { Has } from "@fncts/base/typeclass";
+import type { Spec } from "@fncts/test/control/Spec";
+import type { TestArgs } from "@fncts/test/data/TestArgs";
+import { AbstractRunnableSpec } from "@fncts/test/control/AbstractRunnableSpec";
+import { TestLogger } from "@fncts/test/control/TestLogger";
+export declare abstract class RunnableSpec<R, E> extends AbstractRunnableSpec<R, E> {
+    readonly _tag = "RunnableSpec";
+    run(spec: Spec<R, E>): URIO<Has<TestLogger>, number>;
+    main(_args?: TestArgs): void;
+}
+export declare function isRunnableSpec(u: unknown): u is RunnableSpec<unknown, unknown>;

package/control/Sample/api.d.ts

@@ -0,0 +1,79 @@
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Stream } from "@fncts/io/Stream";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { IO } from "@fncts/io/IO";
+import { Channel } from "@fncts/io/Channel";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { ArrayInt64 } from "@fncts/base/util/rand";
+import { Sample } from "./definition.js";
+/**
+ * @tsplus fluent fncts.test.Sample flatMap
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function flatMap_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => Sample<R1, B>): Sample<R & R1, B>;
+/**
+ * @tsplus fluent fncts.test.Sample filter
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function filter_<R, A>(ma: Sample<R, A>, f: Predicate<A>): Stream<R, never, Maybe<Sample<R, A>>>;
+/**
+ * @tsplus fluent fncts.test.Sample foreach
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function foreach_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => IO<R1, never, B>): IO<R & R1, never, Sample<R & R1, B>>;
+/**
+ * @tsplus fluent fncts.test.Sample map
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function map_<R, A, B>(ma: Sample<R, A>, f: (a: A) => B): Sample<R, B>;
+/**
+ * @tsplus fluent fncts.test.Sample shrinkSearch
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function shrinkSearch_<R, A>(ma: Sample<R, A>, p: Predicate<A>): Stream<R, never, A>;
+/**
+ * @tsplus static fncts.test.SampleOps unfold
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function unfold<R, A, S>(s: S, f: (s: S) => readonly [A, Stream<R, never, S>]): Sample<R, A>;
+/**
+ * @tsplus fluent fncts.test.Sample zip
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function zip<R, A, R1, B>(ma: Sample<R, A>, mb: Sample<R1, B>): Sample<R & R1, readonly [A, B]>;
+/**
+ * @tsplus fluent fncts.test.Sample zipWith
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function zipWith_<R, A, R1, B, C>(ma: Sample<R, A>, mb: Sample<R1, B>, f: (a: A, b: B) => C): Sample<R & R1, C>;
+/**
+ * @tsplus static fncts.test.SampleOps noShrink
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function noShrink<A>(a: A): Sample<unknown, A>;
+/**
+ * @tsplus static fncts.test.SampleOps shrinkFractional
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function shrinkFractional(smallest: number): (a: number) => Sample<unknown, number>;
+/**
+ * @tsplus static fncts.test.SampleOps shrinkBigInt
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function shrinkBigInt(smallest: bigint): (a: bigint) => Sample<unknown, bigint>;
+/**
+ * @tsplus static fncts.test.SampleOps shrinkIntegral
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function shrinkIntegral(smallest: number): (a: number) => Sample<unknown, number>;
+/**
+ * @tsplus static fncts.test.SampleOps shrinkArrayInt64
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function shrinkArrayInt64(target: ArrayInt64): (value: ArrayInt64) => Sample<unknown, ArrayInt64>;
+/**
+ * @tsplus static fncts.test.SampleOps flatMapStream
+ * @tsplus location "@fncts/test/control/Sample/api"
+ */
+export declare function flatMapStream<R, A, R1, B>(stream: Stream<R, never, Maybe<A>>, f: (a: A) => Stream<R1, never, Maybe<B>>): Stream<R & R1, never, Maybe<B>>;

package/control/Sample/definition.d.ts

@@ -0,0 +1,11 @@
+import { Stream } from "@fncts/io/Stream";
+import { Maybe } from "@fncts/base/data/Maybe";
+/**
+ * @tsplus type fncts.test.Sample
+ * @tsplus companion fncts.test.SampleOps
+ */
+export declare class Sample<R, A> {
+    readonly value: A;
+    readonly shrink: Stream<R, never, Maybe<Sample<R, A>>>;
+    constructor(value: A, shrink: Stream<R, never, Maybe<Sample<R, A>>>);
+}

package/control/Sample.d.ts

@@ -0,0 +1,2 @@
+export * from "./Sample/api.js";
+export * from "./Sample/definition.js";

package/control/Sized/api.d.ts

@@ -0,0 +1,13 @@
+import { URIO, IO } from "@fncts/io/IO";
+import { Has } from "@fncts/base/typeclass";
+import { Sized } from "./definition.js";
+/**
+ * @tsplus static fncts.test.SizedOps size
+ * @tsplus location "@fncts/test/control/Sized/api"
+ */
+export declare const size: URIO<Has<Sized>, number>;
+/**
+ * @tsplus static fncts.test.SizedOps withSize
+ * @tsplus location "@fncts/test/control/Sized/api"
+ */
+export declare function withSize(size: number): <R, E, A>(io: import("@fncts/io/IO.js").IO<R, E, A>) => import("@fncts/io/IO.js").IO<R & import("@fncts/base/typeclass.js").Has<Sized>, E, A>;

package/control/Sized/definition.d.ts

@@ -0,0 +1,14 @@
+import { UIO, IO } from "@fncts/io/IO";
+/**
+ * @tsplus type fncts.test.Sized
+ * @tsplus companion fncts.test.SizedOps
+ */
+export declare abstract class Sized {
+    abstract readonly size: UIO<number>;
+    abstract withSize(size: number): <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>;
+}
+/**
+ * @tsplus static fncts.test.SizedOps Tag
+ * @tsplus location "@fncts/test/control/Sized/definition"
+ */
+export declare const SizedTag: import("@fncts/base/data/Tag").Tag<Sized>;

package/control/Sized/live.d.ts

@@ -0,0 +1,9 @@
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass";
+import { IO } from "@fncts/io/IO";
+import { Sized } from "./definition.js";
+/**
+ * @tsplus static fncts.test.SizedOps Live
+ * @tsplus location "@fncts/test/control/Sized/live"
+ */
+export declare function Live(size: number): Layer<unknown, never, Has<Sized>>;

package/control/Sized.d.ts

@@ -0,0 +1,3 @@
+export * from "./Sized/api.js";
+export * from "./Sized/definition.js";
+export * from "./Sized/live.js";

package/control/Spec/api.d.ts

@@ -0,0 +1,159 @@
+import { Has } from "@fncts/base/typeclass";
+import { Environment } from "@fncts/base/data/Environment";
+import { Scope } from "@fncts/io/Scope";
+import { IO } from "@fncts/io/IO";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Cause } from "@fncts/base/data/Cause";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Layer } from "@fncts/io/Layer";
+import { Lazy } from "@fncts/base/data/function/definition";
+import type { Annotated } from "../Annotations.js";
+import type { SpecCase } from "./definition.js";
+import type { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import type { Spreadable } from "@fncts/base/types.js";
+import type { TestArgs } from "@fncts/test/data/TestArgs.js";
+import { TestSuccess } from "@fncts/test/data/TestSuccess";
+import { TestAnnotation } from "../../data/TestAnnotation.js";
+import { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+import { Annotations } from "../Annotations.js";
+import { Spec } from "./definition.js";
+import { PSpec } from "./definition.js";
+/**
+ * @tsplus getter fncts.test.PSpec annotated
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R & Has<Annotations>, Annotated<E>, Annotated<T>>;
+/**
+ * @tsplus fluent fncts.test.PSpec combine
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function combine_<R, E, T, R1, E1, T1>(self: PSpec<R, E, T>, that: PSpec<R1, E1, T1>): PSpec<R & R1, E | E1, T | T1>;
+/**
+ * @tsplus fluent fncts.test.PSpec contramapEnvironment
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function contramapEnvironment_<R, E, T, R0>(self: PSpec<R, E, T>, f: (r0: Environment<R0>) => Environment<R>): PSpec<R0, E, T>;
+/**
+ * @tsplus fluent fncts.test.PSpec countTests
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean): IO<R & Has<Scope>, E, number>;
+/**
+ * @tsplus static fncts.test.PSpecOps empty
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare const empty: PSpec<unknown, never, never>;
+/**
+ * @tsplus static fncts.test.PSpecOps exec
+ * @tsplus static fncts.test.PSpec.ExecCaseOps __call
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function exec<R, E, T>(spec: PSpec<R, E, T>, exec: ExecutionStrategy): PSpec<R, E, T>;
+/**
+ * @tsplus fluent fncts.test.PSpec execute
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function execute<R, E, T>(self: PSpec<R, E, T>, defExec: ExecutionStrategy): IO<R & Has<Scope>, never, PSpec<unknown, E, T>>;
+/**
+ * @tsplus fluent fncts.test.PSpec filterAnnotations
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function filterAnnotations_<R, E, T, V>(spec: PSpec<R, E, T>, key: TestAnnotation<V>, f: (v: V) => boolean): Maybe<PSpec<R, E, T>>;
+/**
+ * @tsplus fluent fncts.test.PSpec filterLabels
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function filterLabels_<R, E, T>(spec: PSpec<R, E, T>, f: (label: string) => boolean): Maybe<PSpec<R, E, T>>;
+/**
+ * @tsplus fluent fncts.test.PSpec filterTags
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function filterTags_<R, E, T>(spec: PSpec<R, E, T>, f: (tag: string) => boolean): Maybe<PSpec<R, E, T>>;
+/**
+ * @tsplus fluent fncts.test.PSpec filterByArgs
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function filterByArgs<R, E>(spec: Spec<R, E>, args: TestArgs): Spec<R, E>;
+/**
+ * @tsplus fluent fncts.test.PSpec fold
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function fold_<R, E, T, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, Z>) => Z): Z;
+/**
+ * @tsplus fluent fncts.test.PSpec foldScoped
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function foldScoped_<R, E, T, R1, E1, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, Z>) => IO<R1 & Has<Scope>, E1, Z>, defExec: ExecutionStrategy): IO<R & R1 & Has<Scope>, E1, Z>;
+/**
+ * @tsplus fluent fncts.test.PSpec foreachExec
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function foreachExec_<R, E, T, R1, E1, A, R2, E2, B>(spec: PSpec<R, E, T>, failure: (c: Cause<E>) => IO<R1, E1, A>, success: (t: T) => IO<R2, E2, B>, defExec: ExecutionStrategy): IO<R & R1 & R2 & Has<Scope>, never, PSpec<R & R1 & R2, E1 | E2, A | B>>;
+/**
+ * @tsplus fluent fncts.test.PSpec labeled
+ * @tsplus static fncts.test.PSpecOps labeled
+ * @tsplus static fncts.test.PSpec.LabeledCaseOps __call
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function labeledCase<R, E, T>(spec: PSpec<R, E, T>, label: string): PSpec<R, E, T>;
+/**
+ * @tsplus fluent fncts.test.PSpec scoped
+ * @tsplus static fncts.test.PSpecOps scoped
+ * @tsplus static fncts.test.PSpec.ScopedCaseOps __call
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function scoped<R, E, T>(managed: IO<R & Has<Scope>, E, PSpec<R, E, T>>): PSpec<R, E, T>;
+/**
+ * @tsplus fluent fncts.test.SpecCase mapError
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function mapError<R, E, T, E1>(self: PSpec<R, E, T>, f: (e: E) => E1): PSpec<R, E1, T>;
+/**
+ * @tsplus fluent fncts.test.SpecCase map
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function mapSpecCase_<R, E, T, A, B>(fa: SpecCase<R, E, T, A>, f: (a: A) => B): SpecCase<R, E, T, B>;
+/**
+ * @tsplus fluent fncts.test.PSpec multiple
+ * @tsplus static fncts.test.PSpecOps multiple
+ * @tsplus static fncts.test.PSpec.MultipleCaseOps __call
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function multipleCase<R, E, T>(specs: Conc<PSpec<R, E, T>>): PSpec<R, E, T>;
+/**
+ * @tsplus fluent fncts.test.PSpec provideEnvironment
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function provideEnvironment_<R, E, T>(self: PSpec<R, E, T>, r: Environment<R>): PSpec<unknown, E, T>;
+/**
+ * @tsplus fluent fncts.test.PSpec provideLayer
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function provideLayer_<RIn, E, ROut extends Spreadable, R, E1, T>(self: PSpec<ROut, E1, T>, layer: Layer<RIn, E, ROut>): PSpec<RIn, E | E1, T>;
+/**
+ * @tsplus fluent fncts.test.PSpec test
+ * @tsplus static fncts.test.PSpecOps test
+ * @tsplus static fncts.test.PSpec.TestCaseOps __call
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function testCase<R, E, T>(test: IO<R, E, T>, annotations: TestAnnotationMap): PSpec<R, E, T>;
+/**
+ * @tsplus fluent fncts.test.PSpec transform
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function transform_<R, E, T, R1, E1, T1>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, PSpec<R1, E1, T1>>) => SpecCase<R1, E1, T1, PSpec<R1, E1, T1>>): PSpec<R1, E1, T1>;
+/**
+ * @tsplus fluent fncts.test.PSpec annotate
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function annotate_<R, E, T, V>(self: PSpec<R, E, T>, key: TestAnnotation<V>, value: V): PSpec<R, E, T>;
+/**
+ * @tsplus fluent fncts.test.PSpec whenIO
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function whenIO_<R, E, R1, E1>(self: PSpec<R, E, TestSuccess>, b: IO<R1, E1, boolean>): PSpec<R & R1 & Has<Annotations>, E | E1, TestSuccess>;
+/**
+ * @tsplus fluent fncts.test.PSpec when
+ * @tsplus location "@fncts/test/control/Spec/api"
+ */
+export declare function when_<R, E>(self: PSpec<R, E, TestSuccess>, b: Lazy<boolean>): PSpec<R & Has<Annotations>, E, TestSuccess>;