@fncts/test 0.0.1

package/control/AbstractRunnableSpec.d.ts

@@ -0,0 +1,15 @@
+import { URIO } from "@fncts/io/IO";
+import { Has } from "@fncts/base/typeclass";
+import type { Spec } from "@fncts/test/control/Spec";
+import type { TestAspect } from "@fncts/test/control/TestAspect";
+import type { TestLogger } from "@fncts/test/control/TestLogger";
+import type { TestRunner } from "@fncts/test/control/TestRunner";
+import type { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
+export declare abstract class AbstractRunnableSpec<R, E> {
+    abstract aspects: ReadonlyArray<TestAspect<R, any>>;
+    abstract runner: TestRunner<R, E>;
+    abstract spec: Spec<R, E>;
+    get _run(): URIO<Has<TestLogger>, ExecutedSpec<E>>;
+    runSpec(spec: Spec<R, E>): URIO<Has<TestLogger>, ExecutedSpec<E>>;
+    get platform(): import("@fncts/io/RuntimeConfig").RuntimeConfig;
+}

package/control/Annotations/api.d.ts

@@ -0,0 +1,26 @@
+import { URIO, IO } from "@fncts/io/IO";
+import { Has } from "@fncts/base/typeclass";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import type { TestAnnotation } from "../../data/TestAnnotation.js";
+import type { Annotated } from "./definition.js";
+import { Annotations } from "./definition.js";
+/**
+ * @tsplus static fncts.test.AnnotationsOps annotate
+ * @tsplus location "@fncts/test/control/Annotations/api"
+ */
+export declare function annotate<V>(key: TestAnnotation<V>, value: V): URIO<Has<Annotations>, void>;
+/**
+ * @tsplus static fncts.test.AnnotationsOps get
+ * @tsplus location "@fncts/test/control/Annotations/api"
+ */
+export declare function get<V>(key: TestAnnotation<V>): URIO<Has<Annotations>, V>;
+/**
+ * @tsplus static fncts.test.AnnotationsOps withAnnotations
+ * @tsplus location "@fncts/test/control/Annotations/api"
+ */
+export declare function withAnnotation<R, E, A>(io: IO<R, E, A>): IO<R & Has<Annotations>, Annotated<E>, Annotated<A>>;
+/**
+ * @tsplus static fncts.test.AnnotationsOps supervisedFibers
+ * @tsplus location "@fncts/test/control/Annotations/api"
+ */
+export declare const supervisedFibers: URIO<Has<Annotations>, HashSet<Fiber.Runtime<any, any>>>;

package/control/Annotations/definition.d.ts

@@ -0,0 +1,20 @@
+import { UIO, IO } from "@fncts/io/IO";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import type { TestAnnotation } from "../../data/TestAnnotation.js";
+import type { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+export declare type Annotated<A> = readonly [A, TestAnnotationMap];
+/**
+ * @tsplus type fncts.test.Annotations
+ * @tsplus companion fncts.test.AnnotationsOps
+ */
+export declare abstract class Annotations {
+    abstract annotate<V>(key: TestAnnotation<V>, value: V): UIO<void>;
+    abstract get<V>(key: TestAnnotation<V>): UIO<V>;
+    abstract withAnnotation<R, E, A>(io: IO<R, E, A>): IO<R, Annotated<E>, Annotated<A>>;
+    abstract readonly supervisedFibers: UIO<HashSet<Fiber.Runtime<any, any>>>;
+}
+/**
+ * @tsplus static fncts.test.AnnotationsOps Tag
+ * @tsplus location "@fncts/test/control/Annotations/definition"
+ */
+export declare const AnnotationsTag: import("@fncts/base/data/Tag.js").Tag<Annotations>;

package/control/Annotations/live.d.ts

@@ -0,0 +1,18 @@
+import { FiberRef } from "@fncts/io/FiberRef";
+import { UIO, IO } from "@fncts/io/IO";
+import { TestAnnotation } from "../../data/TestAnnotation.js";
+import { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+import { Annotations } from "./definition.js";
+export declare class LiveAnnotations extends Annotations {
+    private fiberRef;
+    constructor(fiberRef: FiberRef<TestAnnotationMap>);
+    annotate<V>(key: TestAnnotation<V>, value: V): UIO<void>;
+    get<V>(key: TestAnnotation<V>): import("@fncts/io/IO.js").IO<unknown, never, V>;
+    withAnnotation<R, E, A>(io: IO<R, E, A>): import("@fncts/io/IO.js").IO<R, readonly [E, TestAnnotationMap], readonly [A, TestAnnotationMap]>;
+    supervisedFibers: import("@fncts/io/IO.js").IO<unknown, never, import("@fncts/base/collection/immutable/HashSet.js").HashSet<import("@fncts/io/Fiber.js").Fiber.Runtime<any, any>>>;
+}
+/**
+ * @tsplus static fncts.test.AnnotationsOps Live
+ * @tsplus location "@fncts/test/control/Annotations/live"
+ */
+export declare const live: import("@fncts/io/Layer.js").Layer<unknown, never, import("@fncts/base/typeclass.js").Has<Annotations>>;

package/control/Annotations.d.ts

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

package/control/Assertion/api.d.ts

@@ -0,0 +1,81 @@
+import { LazyValue } from "@fncts/base/control/LazyValue";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Cause } from "@fncts/base/data/Cause";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { Eq } from "@fncts/base/typeclass";
+import { AssertionData } from "../../data/AssertionData.js";
+import { AssertionValue } from "../../data/AssertionValue.js";
+import { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
+import { RenderParam } from "../../data/RenderParam.js";
+import { Assertion } from "./definition.js";
+/**
+ * @tsplus fluent fncts.test.Assertion and
+ * @tsplus operator fncts.test.Assertion &&
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function and_<A>(self: Assertion<A>, that: Assertion<A>): Assertion<A>;
+/**
+ * @tsplus static fncts.test.AssertionOps anything
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare const anything: Assertion<any>;
+/**
+ * @tsplus static fncts.test.AssertionOps approximatelyEquals
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function approximatelyEquals(reference: number, tolerance: number): Assertion<number>;
+/**
+ * @tsplus static fncts.test.AssertionOps make
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function assertion<A>(name: string, params: ReadonlyArray<RenderParam>, run: (actual: A) => boolean): Assertion<A>;
+/**
+ * @tsplus static fncts.test.AssertionOps direct
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function assertionDirect<A>(name: string, params: ReadonlyArray<RenderParam>, run: (actual: A) => FreeBooleanAlgebra<AssertionValue<A>>): Assertion<A>;
+/**
+ * @tsplus static fncts.test.AssertionOps rec
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function assertionRec<A, B>(name: string, params: ReadonlyArray<RenderParam>, assertion: Assertion<B>, get: (a: A) => Maybe<B>, orElse?: (data: AssertionData<A>) => FreeBooleanAlgebra<AssertionValue<A>>): Assertion<A>;
+export declare function contains<A>(element: A): Assertion<Iterable<A>>;
+export declare function containsCause<E>(cause: Cause<E>): Assertion<Cause<E>>;
+export declare function containsString(element: string): Assertion<string>;
+export declare function exists<A>(assertion: Assertion<A>): Assertion<Iterable<A>>;
+export declare function fails<E>(assertion: Assertion<E>): Assertion<Exit<E, any>>;
+export declare function forall<A>(assertion: Assertion<A>): Assertion<Iterable<A>>;
+export declare function halts(assertion: Assertion<any>): Assertion<Exit<any, any>>;
+export declare function strictEqualTo<A>(expected: A): Assertion<A>;
+export declare function deepEqualTo<A>(expected: A): Assertion<A>;
+export declare function equals<A>(expected: A, E: Eq<A>): Assertion<A>;
+export declare const isFalse: Assertion<boolean>;
+export declare const isInterrupted: Assertion<Exit<any, any>>;
+export declare function isLeft<A>(assertion: Assertion<A>): Assertion<Either<A, any>>;
+export declare function isJust<A>(assertion: Assertion<A>): Assertion<Maybe<A>>;
+export declare const isNothing: Assertion<Maybe<any>>;
+export declare function isRight<A>(assertion: Assertion<A>): Assertion<Either<any, A>>;
+export declare const isTrue: Assertion<boolean>;
+/**
+ * @tsplus fluent fncts.test.Assertion label
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function label_<A>(self: Assertion<A>, label: string): Assertion<A>;
+/**
+ * @tsplus getter fncts.test.Assertion invert
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function not<A>(assertion: Assertion<A>): Assertion<A>;
+/**
+ * @tsplus fluent fncts.test.Assertion or
+ * @tsplus operator fncts.test.Assertion ||
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function or_<A>(self: Assertion<A>, that: Assertion<A>): Assertion<A>;
+export declare function succeeds<A>(assertion: Assertion<A>): Assertion<Exit<any, A>>;
+/**
+ * @tsplus fluent fncts.test.Assertion test
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
+export declare function test_<A>(self: Assertion<A>, actual: A): boolean;

package/control/Assertion/definition.d.ts

@@ -0,0 +1,17 @@
+import type { AssertionValue } from "../../data/AssertionValue.js";
+import type { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
+import type { Render } from "../../data/Render.js";
+import { AssertionIO } from "../AssertionIO.js";
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebra
+ */
+export declare type AssertResult<A> = FreeBooleanAlgebra<AssertionValue<A>>;
+/**
+ * @tsplus type fncts.test.Assertion
+ * @tsplus companion fncts.test.AssertionOps
+ */
+export declare class Assertion<A> extends AssertionIO<A> {
+    readonly render: Render;
+    readonly run: (actual: A) => AssertResult<A>;
+    constructor(render: Render, run: (actual: A) => AssertResult<A>);
+}

package/control/Assertion.d.ts

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

package/control/AssertionIO/api.d.ts

@@ -0,0 +1,18 @@
+import { AssertionIO } from "./definition.js";
+/**
+ * @tsplus fluent fncts.test.AssertionIO and
+ * @tsplus operator fncts.test.AssertionIO &&
+ * @tsplus location "@fncts/test/control/AssertionIO/api"
+ */
+export declare function and_<A>(self: AssertionIO<A>, that: AssertionIO<A>): AssertionIO<A>;
+/**
+ * @tsplus fluent fncts.test.AssertionIO or
+ * @tsplus operator fncts.test.AssertionIO ||
+ * @tsplus location "@fncts/test/control/AssertionIO/api"
+ */
+export declare function or_<A>(self: AssertionIO<A>, that: AssertionIO<A>): AssertionIO<A>;
+/**
+ * @tsplus fluent fncts.test.AssertionIO label
+ * @tsplus location "@fncts/test/control/AssertionIO/api"
+ */
+export declare function label_<A>(self: AssertionIO<A>, label: string): AssertionIO<A>;

package/control/AssertionIO/definition.d.ts

@@ -0,0 +1,18 @@
+import type { AssertionValue } from "../../data/AssertionValue.js";
+import type { Render } from "../../data/Render.js";
+import type { FreeBooleanAlgebraIO } from "../FreeBooleanAlgebraIO.js";
+export declare type AssertResultIO<A> = FreeBooleanAlgebraIO<unknown, never, AssertionValue<A>>;
+export declare const AssertionIOTypeId: unique symbol;
+export declare type AssertionIOTypeId = typeof AssertionIOTypeId;
+/**
+ * @tsplus type fncts.test.AssertionIO
+ * @tsplus companion fncts.test.AssertionIOOps
+ */
+export declare class AssertionIO<A> {
+    readonly render: Render;
+    readonly runIO: (actual: A) => AssertResultIO<A>;
+    readonly _typeId: AssertionIOTypeId;
+    constructor(render: Render, runIO: (actual: A) => AssertResultIO<A>);
+    get rendered(): string;
+}
+export declare function isAssertionIO(u: unknown): u is AssertionIO<unknown>;

package/control/AssertionIO.d.ts

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

package/control/DefaultRunnableSpec.d.ts

@@ -0,0 +1,7 @@
+import { RunnableSpec } from "@fncts/test/control/RunnableSpec";
+import { TestEnvironment } from "@fncts/test/control/TestEnvironment";
+import { TestRunner } from "@fncts/test/control/TestRunner";
+export declare abstract class DefaultRunnableSpec extends RunnableSpec<TestEnvironment, any> {
+    aspects: import("@fncts/test/control/TestAspect").TestAspect<import("@fncts/base/typeclass").Has<import("./Live").Live>, any>[];
+    runner: TestRunner<import("@fncts/base/typeclass").Has<import("./Live").Live> & import("@fncts/base/typeclass").Has<import("./Sized").Sized> & import("@fncts/base/typeclass").Has<import("./TestClock").TestClock> & import("@fncts/base/typeclass").Has<import("../data/TestConfig").TestConfig> & import("@fncts/base/typeclass").Has<import("./TestRandom").TestRandom> & import("@fncts/base/typeclass").Has<import("@fncts/io/Clock").Clock> & import("@fncts/base/typeclass").Has<import("@fncts/io/Random").Random> & import("@fncts/base/typeclass").Has<import("@fncts/io/Console").Console> & import("@fncts/base/typeclass").Has<import("./TestConsole").TestConsole> & import("@fncts/base/typeclass").Has<import("./Annotations").Annotations>, unknown>;
+}

package/control/DefaultTestReporter/definition.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus type fncts.test.DefaultTestReporter
+ */
+export interface DefaultTestReporter {
+}
+export declare const DefaultTestReporter: DefaultTestReporter;

package/control/DefaultTestReporter/render.d.ts

@@ -0,0 +1,23 @@
+import { URIO } from "@fncts/io/IO";
+import { Has } from "@fncts/base/typeclass";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { List, Cons } from "@fncts/base/collection/immutable/List";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Cause } from "@fncts/base/data/Cause";
+import type { ExecutedSpec } from "../../data/ExecutedSpec.js";
+import type { ExecutionResult } from "../../data/ExecutionResult.js";
+import type { TestAnnotationRenderer } from "../TestAnnotationRenderer.js";
+import type { TestRenderer } from "../TestRenderer/definition.js";
+import { TestLogger } from "../TestLogger.js";
+export declare type TestReporter<E> = (duration: number, spec: ExecutedSpec<E>) => URIO<Has<TestLogger>, void>;
+/**
+ * @tsplus static fncts.test.DefaultTestReporter report
+ * @tsplus location "@fncts/test/control/DefaultTestReporter/render"
+ */
+export declare function report<E>(renderTest: TestRenderer, testAnnotationRenderer: TestAnnotationRenderer): TestReporter<E>;
+export declare function renderStats<E>(duration: number, executedSpec: ExecutedSpec<E>): ExecutionResult;
+/**
+ * @tsplus static fncts.test.DefaultTestRenderer render
+ * @tsplus location "@fncts/test/control/DefaultTestReporter/render"
+ */
+export declare function render<E>(executedSpec: ExecutedSpec<E>): Vector<ExecutionResult>;

package/control/DefaultTestReporter.d.ts

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

package/control/FreeBooleanAlgebraIO/api.d.ts

@@ -0,0 +1,44 @@
+import { IO } from "@fncts/io/IO";
+import type { FreeBooleanAlgebraIO } from "./definition.js";
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebraIO and
+ * @tsplus operator fncts.test.FreeBooleanAlgebraIO &&
+ * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
+ */
+export declare function and_<R, E, A extends A1, R1, E1, A1>(self: FreeBooleanAlgebraIO<R, E, A>, that: FreeBooleanAlgebraIO<R1, E1, A1>): FreeBooleanAlgebraIO<R & R1, E | E1, A | A1>;
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebraIO or
+ * @tsplus operator fncts.test.FreeBooleanAlgebraIO ||
+ * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
+ */
+export declare function or_<R, E, A extends A1, R1, E1, A1>(self: FreeBooleanAlgebraIO<R, E, A>, that: FreeBooleanAlgebraIO<R1, E1, A1>): FreeBooleanAlgebraIO<R & R1, E | E1, A | A1>;
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebraIO invert
+ * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
+ */
+export declare function not<R, E, A>(self: FreeBooleanAlgebraIO<R, E, A>): FreeBooleanAlgebraIO<R, E, A>;
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebraIO isSuccess
+ * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
+ */
+export declare function isSuccess<R, E, A>(self: FreeBooleanAlgebraIO<R, E, A>): IO<R, E, boolean>;
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebraIO isFailure
+ * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
+ */
+export declare function isFailure<R, E, A>(self: FreeBooleanAlgebraIO<R, E, A>): IO<R, E, boolean>;
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraIOOps success
+ * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
+ */
+export declare function success<A>(a: A): FreeBooleanAlgebraIO<unknown, never, A>;
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraIOOps failure
+ * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
+ */
+export declare function failure<A>(a: A): FreeBooleanAlgebraIO<unknown, never, A>;
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraIOOps fromIO
+ * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
+ */
+export declare function fromIO<R, E, A>(io: IO<R, E, A>): FreeBooleanAlgebraIO<R, E, A>;

package/control/FreeBooleanAlgebraIO/definition.d.ts

@@ -0,0 +1,12 @@
+import { IO } from "@fncts/io/IO";
+import type { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebraIO
+ */
+export declare type FreeBooleanAlgebraIO<R, E, A> = IO<R, E, FreeBooleanAlgebra<A>>;
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebraIOOps
+ */
+export interface FreeBooleanAlgebraIOOps {
+}
+export declare const FreeBooleanAlgebraIO: FreeBooleanAlgebraIOOps;

package/control/FreeBooleanAlgebraIO.d.ts

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

package/control/Gen/api/array.d.ts

@@ -0,0 +1,19 @@
+import { Has } from "@fncts/base/typeclass";
+import type { Sized } from "../../Sized.js";
+import type { EqConstraint, LengthConstraints } from "../constraints.js";
+import { Gen } from "../definition.js";
+/**
+ * @tsplus fluent fncts.test.Gen array
+ * @tsplus location "@fncts/test/control/Gen/api/array"
+ */
+export declare function array<R, A>(g: Gen<R, A>, constraints?: LengthConstraints): Gen<R & Has<Sized>, ReadonlyArray<A>>;
+/**
+ * @tsplus fluent fncts.test.Gen arrayN
+ * @tsplus location "@fncts/test/control/Gen/api/array"
+ */
+export declare function arrayN_<R, A>(self: Gen<R, A>, n: number): Gen<R, ReadonlyArray<A>>;
+/**
+ * @tsplus fluent fncts.test.Gen uniqueArray
+ * @tsplus location "@fncts/test/control/Gen/api/array"
+ */
+export declare function uniqueArray_<R, A>(gen: Gen<R, A>, constraints?: LengthConstraints & EqConstraint<A>): Gen<Has<Sized> & R, ReadonlyArray<A>>;

package/control/Gen/api/char.d.ts

@@ -0,0 +1,47 @@
+import type { NumberConstraints } from "../constraints.js";
+import { Gen } from "../definition.js";
+/**
+ * @tsplus static fncts.test.GenOps alphaNumericChar
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare const alphaNumericChar: Gen<unknown, string>;
+/**
+ * @tsplus static fncts.test.GenOps asciiChar
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare const asciiChar: Gen<unknown, string>;
+/**
+ * @tsplus static fncts.test.GenOps base64Char
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare const base64Char: Gen<unknown, string>;
+/**
+ * @tsplus static fncts.test.GenOps char
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare function char(constraints: Required<NumberConstraints>): Gen<unknown, string>;
+/**
+ * @tsplus static fncts.test.GenOps char16
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare const char16: Gen<unknown, string>;
+/**
+ * @tsplus static fncts.test.GenOps fullUnicodeChar
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare const fullUnicodeChar: Gen<unknown, string>;
+/**
+ * @tsplus static fncts.test.GenOps hexChar
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare const hexChar: Gen<unknown, string>;
+/**
+ * @tsplus static fncts.test.GenOps printableChar
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare const printableChar: Gen<unknown, string>;
+/**
+ * @tsplus static fncts.test.GenOps unicodeChar
+ * @tsplus location "@fncts/test/control/Gen/api/char"
+ */
+export declare const unicodeChar: Gen<unknown, string>;

package/control/Gen/api/conc.d.ts

@@ -0,0 +1,26 @@
+import { Has } from "@fncts/base/typeclass";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { Sized } from "../../Sized.js";
+import type { EqConstraint, LengthConstraints } from "../constraints.js";
+import { Eq } from "@fncts/base/typeclass";
+import { Gen } from "../definition.js";
+/**
+ * @tsplus fluent fncts.test.Gen conc
+ * @tsplus location "@fncts/test/control/Gen/api/conc"
+ */
+export declare function conc<R, A>(self: Gen<R, A>, constraints?: LengthConstraints): Gen<R & Has<Sized>, Conc<A>>;
+/**
+ * @tsplus fluent fncts.test.Gen concN
+ * @tsplus location "@fncts/test/control/Gen/api/conc"
+ */
+export declare function concN_<R, A>(g: Gen<R, A>, n: number): Gen<R, Conc<A>>;
+/**
+ * @tsplus fluent fncts.test.Gen uniqueConc
+ * @tsplus location "@fncts/test/control/Gen/api/conc"
+ */
+export declare function uniqueConc_<R, A>(self: Gen<R, A>, constraints?: LengthConstraints & EqConstraint<A>): Gen<Has<Sized> & R, Conc<A>>;
+/**
+ * @tsplus getter fncts.test.Gen uniqueConcN
+ * @tsplus location "@fncts/test/control/Gen/api/conc"
+ */
+export declare function uniqueConcN_<R, A>(self: Gen<R, A>): (E: Eq<A>) => (n: number) => Gen<R, Conc<A>>;

package/control/Gen/api/double.d.ts

@@ -0,0 +1,13 @@
+import type { FloatConstraints, NumberConstraints } from "../constraints.js";
+import type { ArrayInt64 } from "@fncts/base/util/rand";
+import { Gen } from "../definition.js";
+/**
+ * @tsplus static fncts.test.GenOps arrayInt64
+ * @tsplus location "@fncts/test/control/Gen/api/double"
+ */
+export declare function arrayInt64(min: ArrayInt64, max: ArrayInt64): Gen<unknown, ArrayInt64>;
+/**
+ * @tsplus static fncts.test.GenOps double
+ * @tsplus location "@fncts/test/control/Gen/api/double"
+ */
+export declare function double(constraints?: NumberConstraints & FloatConstraints): Gen<unknown, number>;

package/control/Gen/api/float.d.ts

@@ -0,0 +1,7 @@
+import type { FloatConstraints, NumberConstraints } from "../constraints.js";
+import { Gen } from "../definition.js";
+/**
+ * @tsplus static fncts.test.GenOps float
+ * @tsplus location "@fncts/test/control/Gen/api/float"
+ */
+export declare function float(constraints?: NumberConstraints & FloatConstraints): Gen<unknown, number>;

package/control/Gen/api/string.d.ts

@@ -0,0 +1,49 @@
+import { Has } from "@fncts/base/typeclass";
+import type { Sized } from "../../Sized.js";
+import type { LengthConstraints } from "../constraints.js";
+import { Gen } from "../definition.js";
+/**
+ * @tsplus static fncts.test.GenOps asciiString
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function asciiString<R>(constraints?: LengthConstraints): Gen<R & Has<Sized>, string>;
+/**
+ * @tsplus static fncts.test.GenOps alphaNumericString
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function alphaNumericString(constraints?: LengthConstraints): Gen<unknown & Has<Sized>, string>;
+/**
+ * @tsplus static fncts.test.GenOps base64String
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function base64String(constraints?: LengthConstraints): Gen<unknown & Has<Sized>, string>;
+/**
+ * @tsplus static fncts.test.GenOps fullUnicodeString
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function fullUnicodeString(constraints?: LengthConstraints): Gen<unknown & Has<Sized>, string>;
+/**
+ * @tsplus static fncts.test.GenOps hexString
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function hexString(constraints?: LengthConstraints): Gen<unknown & Has<Sized>, string>;
+/**
+ * @tsplus static fncts.test.GenOps string16
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function string16(constraints?: LengthConstraints): Gen<unknown & Has<Sized>, string>;
+/**
+ * @tsplus fluent fncts.test.Gen string
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function string<R>(char: Gen<R, string>, constraints?: LengthConstraints): Gen<R & Has<Sized>, string>;
+/**
+ * @tsplus fluent fncts.test.Gen stringN
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function stringN<R>(char: Gen<R, string>, n: number): Gen<R, string>;
+/**
+ * @tsplus static fncts.test.GenOps unicodeString
+ * @tsplus location "@fncts/test/control/Gen/api/string"
+ */
+export declare function unicodeString(constraints?: LengthConstraints): Gen<unknown & Has<Sized>, string>;

package/control/Gen/api/struct.d.ts

@@ -0,0 +1,8 @@
+import type { _A, _R } from "@fncts/base/types";
+import { Gen } from "../definition.js";
+export declare function struct<P extends Record<string, Gen<any, any>>>(properties: P): Gen<_R<P[keyof P]>, {
+    readonly [K in keyof P]: _A<P[K]>;
+}>;
+export declare function partial<P extends Record<string, Gen<any, any>>>(properties: P): Gen<unknown & _R<P[keyof P]>, Partial<{
+    readonly [K in keyof P]: _A<P[K]>;
+}>>;