effect 3.13.8 → 3.13.9

package/dist/dts/Predicate.d.ts

@@ -61,11 +61,9 @@ export declare namespace Refinement {
 /**
  * Given a `Predicate<A>` returns a `Predicate<B>`
  *
- * @param self - the `Predicate<A>` to be transformed to `Predicate<B>`.
- * @param f - a function to transform `B` to `A`.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Predicate, Number } from "effect"
  *
  * const minLength3 = Predicate.mapInput(Number.greaterThan(2), (s: string) => s.length)
@@ -83,11 +81,9 @@ export declare const mapInput: {
     /**
      * Given a `Predicate<A>` returns a `Predicate<B>`
      *
-     * @param self - the `Predicate<A>` to be transformed to `Predicate<B>`.
-     * @param f - a function to transform `B` to `A`.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate, Number } from "effect"
      *
      * const minLength3 = Predicate.mapInput(Number.greaterThan(2), (s: string) => s.length)
@@ -105,11 +101,9 @@ export declare const mapInput: {
     /**
      * Given a `Predicate<A>` returns a `Predicate<B>`
      *
-     * @param self - the `Predicate<A>` to be transformed to `Predicate<B>`.
-     * @param f - a function to transform `B` to `A`.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate, Number } from "effect"
      *
      * const minLength3 = Predicate.mapInput(Number.greaterThan(2), (s: string) => s.length)
@@ -130,11 +124,9 @@ export declare const mapInput: {
  *
  * An `Array` is considered to be a `TupleOf` if its length is exactly `N`.
  *
- * @param self - The `Array` to check.
- * @param n - The exact number of elements that the `Array` should have to be considered a `TupleOf`.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isTupleOf } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isTupleOf([1, 2, 3], 3), true);
@@ -157,11 +149,9 @@ export declare const isTupleOf: {
      *
      * An `Array` is considered to be a `TupleOf` if its length is exactly `N`.
      *
-     * @param self - The `Array` to check.
-     * @param n - The exact number of elements that the `Array` should have to be considered a `TupleOf`.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { isTupleOf } from "effect/Predicate"
      *
      * assert.deepStrictEqual(isTupleOf([1, 2, 3], 3), true);
@@ -184,11 +174,9 @@ export declare const isTupleOf: {
      *
      * An `Array` is considered to be a `TupleOf` if its length is exactly `N`.
      *
-     * @param self - The `Array` to check.
-     * @param n - The exact number of elements that the `Array` should have to be considered a `TupleOf`.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { isTupleOf } from "effect/Predicate"
      *
      * assert.deepStrictEqual(isTupleOf([1, 2, 3], 3), true);
@@ -212,11 +200,9 @@ export declare const isTupleOf: {
  *
  * An `Array` is considered to be a `TupleOfAtLeast` if its length is at least `N`.
  *
- * @param self - The `Array` to check.
- * @param n - The minimum number of elements that the `Array` should have to be considered a `TupleOfAtLeast`.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isTupleOfAtLeast } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 3), true);
@@ -239,11 +225,9 @@ export declare const isTupleOfAtLeast: {
      *
      * An `Array` is considered to be a `TupleOfAtLeast` if its length is at least `N`.
      *
-     * @param self - The `Array` to check.
-     * @param n - The minimum number of elements that the `Array` should have to be considered a `TupleOfAtLeast`.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { isTupleOfAtLeast } from "effect/Predicate"
      *
      * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 3), true);
@@ -266,11 +250,9 @@ export declare const isTupleOfAtLeast: {
      *
      * An `Array` is considered to be a `TupleOfAtLeast` if its length is at least `N`.
      *
-     * @param self - The `Array` to check.
-     * @param n - The minimum number of elements that the `Array` should have to be considered a `TupleOfAtLeast`.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { isTupleOfAtLeast } from "effect/Predicate"
      *
      * assert.deepStrictEqual(isTupleOfAtLeast([1, 2, 3], 3), true);
@@ -292,10 +274,9 @@ export declare const isTupleOfAtLeast: {
 /**
  * Tests if a value is `truthy`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isTruthy } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isTruthy(1), true)
@@ -310,10 +291,9 @@ export declare const isTruthy: (input: unknown) => boolean;
 /**
  * Tests if a value is a `Set`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isSet } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isSet(new Set([1, 2])), true)
@@ -330,10 +310,9 @@ export declare const isSet: (input: unknown) => input is Set<unknown>;
 /**
  * Tests if a value is a `Map`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isMap } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isMap(new Map()), true)
@@ -349,10 +328,9 @@ export declare const isMap: (input: unknown) => input is Map<unknown, unknown>;
 /**
  * Tests if a value is a `string`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isString } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isString("a"), true)
@@ -367,10 +345,9 @@ export declare const isString: (input: unknown) => input is string;
 /**
  * Tests if a value is a `number`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isNumber } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isNumber(2), true)
@@ -385,10 +362,9 @@ export declare const isNumber: (input: unknown) => input is number;
 /**
  * Tests if a value is a `boolean`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isBoolean } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isBoolean(true), true)
@@ -403,10 +379,9 @@ export declare const isBoolean: (input: unknown) => input is boolean;
 /**
  * Tests if a value is a `bigint`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isBigInt } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isBigInt(1n), true)
@@ -421,10 +396,9 @@ export declare const isBigInt: (input: unknown) => input is bigint;
 /**
  * Tests if a value is a `symbol`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isSymbol } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isSymbol(Symbol.for("a")), true)
@@ -439,10 +413,9 @@ export declare const isSymbol: (input: unknown) => input is symbol;
 /**
  * Tests if a value is a `function`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isFunction } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isFunction(isFunction), true)
@@ -457,10 +430,9 @@ export declare const isFunction: (input: unknown) => input is Function;
 /**
  * Tests if a value is `undefined`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isUndefined } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isUndefined(undefined), true)
@@ -476,10 +448,9 @@ export declare const isUndefined: (input: unknown) => input is undefined;
 /**
  * Tests if a value is not `undefined`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isNotUndefined } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isNotUndefined(null), true)
@@ -495,10 +466,9 @@ export declare const isNotUndefined: <A>(input: A) => input is Exclude<A, undefi
 /**
  * Tests if a value is `null`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isNull } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isNull(null), true)
@@ -514,10 +484,9 @@ export declare const isNull: (input: unknown) => input is null;
 /**
  * Tests if a value is not `null`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isNotNull } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isNotNull(undefined), true)
@@ -533,10 +502,9 @@ export declare const isNotNull: <A>(input: A) => input is Exclude<A, null>;
 /**
  * A guard that always fails.
  *
- * @param _ - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isNever } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isNever(null), false)
@@ -552,10 +520,9 @@ export declare const isNever: (input: unknown) => input is never;
 /**
  * A guard that always succeeds.
  *
- * @param _ - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isUnknown } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isUnknown(null), true)
@@ -572,10 +539,9 @@ export declare const isUnknown: (input: unknown) => input is unknown;
 /**
  * Tests if a value is an `object`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isObject } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isObject({}), true)
@@ -592,9 +558,6 @@ export declare const isObject: (input: unknown) => input is object;
 /**
  * Checks whether a value is an `object` containing a specified property key.
  *
- * @param property - The field to check within the object.
- * @param self - The value to examine.
- *
  * @category guards
  * @since 2.0.0
  */
@@ -602,9 +565,6 @@ export declare const hasProperty: {
     /**
      * Checks whether a value is an `object` containing a specified property key.
      *
-     * @param property - The field to check within the object.
-     * @param self - The value to examine.
-     *
      * @category guards
      * @since 2.0.0
      */
@@ -614,9 +574,6 @@ export declare const hasProperty: {
     /**
      * Checks whether a value is an `object` containing a specified property key.
      *
-     * @param property - The field to check within the object.
-     * @param self - The value to examine.
-     *
      * @category guards
      * @since 2.0.0
      */
@@ -627,11 +584,9 @@ export declare const hasProperty: {
 /**
  * Tests if a value is an `object` with a property `_tag` that matches the given tag.
  *
- * @param input - The value to test.
- * @param tag - The tag to test for.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isTagged } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isTagged(1, "a"), false)
@@ -649,11 +604,9 @@ export declare const isTagged: {
     /**
      * Tests if a value is an `object` with a property `_tag` that matches the given tag.
      *
-     * @param input - The value to test.
-     * @param tag - The tag to test for.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { isTagged } from "effect/Predicate"
      *
      * assert.deepStrictEqual(isTagged(1, "a"), false)
@@ -673,11 +626,9 @@ export declare const isTagged: {
     /**
      * Tests if a value is an `object` with a property `_tag` that matches the given tag.
      *
-     * @param input - The value to test.
-     * @param tag - The tag to test for.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { isTagged } from "effect/Predicate"
      *
      * assert.deepStrictEqual(isTagged(1, "a"), false)
@@ -698,10 +649,9 @@ export declare const isTagged: {
 /**
  * A guard that succeeds when the input is `null` or `undefined`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isNullable } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isNullable(null), true)
@@ -718,10 +668,9 @@ export declare const isNullable: <A>(input: A) => input is Extract<A, null | und
 /**
  * A guard that succeeds when the input is not `null` or `undefined`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isNotNullable } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isNotNullable({}), true)
@@ -738,10 +687,9 @@ export declare const isNotNullable: <A>(input: A) => input is NonNullable<A>;
 /**
  * A guard that succeeds when the input is an `Error`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isError } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isError(new Error()), true)
@@ -757,10 +705,9 @@ export declare const isError: (input: unknown) => input is Error;
 /**
  * A guard that succeeds when the input is a `Uint8Array`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isUint8Array } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isUint8Array(new Uint8Array()), true)
@@ -776,10 +723,9 @@ export declare const isUint8Array: (input: unknown) => input is Uint8Array;
 /**
  * A guard that succeeds when the input is a `Date`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isDate } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isDate(new Date()), true)
@@ -795,10 +741,9 @@ export declare const isDate: (input: unknown) => input is Date;
 /**
  * A guard that succeeds when the input is an `Iterable`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isIterable } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isIterable([]), true)
@@ -815,10 +760,9 @@ export declare const isIterable: (input: unknown) => input is Iterable<unknown>;
 /**
  * A guard that succeeds when the input is a record.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isRecord } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isRecord({}), true)
@@ -840,10 +784,9 @@ export declare const isRecord: (input: unknown) => input is {
 /**
  * A guard that succeeds when the input is a readonly record.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isReadonlyRecord } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isReadonlyRecord({}), true)
@@ -864,10 +807,9 @@ export declare const isReadonlyRecord: (input: unknown) => input is {
 /**
  * A guard that succeeds when the input is a Promise.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isPromise } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isPromise({}), false)
@@ -886,10 +828,9 @@ export declare const isPromiseLike: (input: unknown) => input is PromiseLike<unk
 /**
  * Tests if a value is a `RegExp`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Predicate } from "effect"
  *
  * assert.deepStrictEqual(Predicate.isRegExp(/a/), true)
@@ -939,7 +880,7 @@ export declare const productMany: <A>(self: Predicate<A>, collection: Iterable<P
 /**
  * Similar to `Promise.all` but operates on `Predicate`s.
  *
- * ```
+ * ```ts skip-type-checking
  * [Refinement<A, B>, Refinement<C, D>, ...] -> Refinement<[A, C, ...], [B, D, ...]>
  * [Predicate<A>, Predicate<B>, ...] -> Predicate<[A, B, ...]>
  * [Refinement<A, B>, Predicate<C>, ...] -> Refinement<[A, C, ...], [B, C, ...]>
@@ -951,7 +892,7 @@ export declare const tuple: {
     /**
      * Similar to `Promise.all` but operates on `Predicate`s.
      *
-     * ```
+     * ```ts skip-type-checking
      * [Refinement<A, B>, Refinement<C, D>, ...] -> Refinement<[A, C, ...], [B, D, ...]>
      * [Predicate<A>, Predicate<B>, ...] -> Predicate<[A, B, ...]>
      * [Refinement<A, B>, Predicate<C>, ...] -> Refinement<[A, C, ...], [B, C, ...]>
@@ -968,7 +909,7 @@ export declare const tuple: {
     }>;
 };
 /**
- * ```
+ * ```ts skip-type-checking
  * { ab: Refinement<A, B>; cd: Refinement<C, D>, ... } -> Refinement<{ ab: A; cd: C; ... }, { ab: B; cd: D; ... }>
  * { a: Predicate<A, B>; b: Predicate<B>, ... } -> Predicate<{ a: A; b: B; ... }>
  * { ab: Refinement<A, B>; c: Predicate<C>, ... } -> Refinement<{ ab: A; c: C; ... }, { ab: B; c: С; ... }>
@@ -978,7 +919,7 @@ export declare const tuple: {
  */
 export declare const struct: {
     /**
-     * ```
+     * ```ts skip-type-checking
      * { ab: Refinement<A, B>; cd: Refinement<C, D>, ... } -> Refinement<{ ab: A; cd: C; ... }, { ab: B; cd: D; ... }>
      * { a: Predicate<A, B>; b: Predicate<B>, ... } -> Predicate<{ a: A; b: B; ... }>
      * { ab: Refinement<A, B>; c: Predicate<C>, ... } -> Refinement<{ ab: A; c: C; ... }, { ab: B; c: С; ... }>
@@ -997,10 +938,9 @@ export declare const struct: {
 /**
  * Negates the result of a given predicate.
  *
- * @param self - A predicate.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Predicate, Number } from "effect"
  *
  * const isPositive = Predicate.not(Number.lessThan(0))
@@ -1017,11 +957,9 @@ export declare const not: <A>(self: Predicate<A>) => Predicate<A>;
 /**
  * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
  *
- * @param self - A predicate.
- * @param that - A predicate.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Predicate, Number } from "effect"
  *
  * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
@@ -1038,11 +976,9 @@ export declare const or: {
     /**
      * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
      *
-     * @param self - A predicate.
-     * @param that - A predicate.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate, Number } from "effect"
      *
      * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
@@ -1059,11 +995,9 @@ export declare const or: {
     /**
      * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
      *
-     * @param self - A predicate.
-     * @param that - A predicate.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate, Number } from "effect"
      *
      * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
@@ -1080,11 +1014,9 @@ export declare const or: {
     /**
      * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
      *
-     * @param self - A predicate.
-     * @param that - A predicate.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate, Number } from "effect"
      *
      * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
@@ -1101,11 +1033,9 @@ export declare const or: {
     /**
      * Combines two predicates into a new predicate that returns `true` if at least one of the predicates returns `true`.
      *
-     * @param self - A predicate.
-     * @param that - A predicate.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate, Number } from "effect"
      *
      * const nonZero = Predicate.or(Number.lessThan(0), Number.greaterThan(0))
@@ -1123,11 +1053,9 @@ export declare const or: {
 /**
  * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
  *
- * @param self - A predicate.
- * @param that - A predicate.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Predicate } from "effect"
  *
  * const minLength = (n: number) => (s: string) => s.length >= n
@@ -1147,11 +1075,9 @@ export declare const and: {
     /**
      * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
      *
-     * @param self - A predicate.
-     * @param that - A predicate.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate } from "effect"
      *
      * const minLength = (n: number) => (s: string) => s.length >= n
@@ -1171,11 +1097,9 @@ export declare const and: {
     /**
      * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
      *
-     * @param self - A predicate.
-     * @param that - A predicate.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate } from "effect"
      *
      * const minLength = (n: number) => (s: string) => s.length >= n
@@ -1195,11 +1119,9 @@ export declare const and: {
     /**
      * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
      *
-     * @param self - A predicate.
-     * @param that - A predicate.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate } from "effect"
      *
      * const minLength = (n: number) => (s: string) => s.length >= n
@@ -1219,11 +1141,9 @@ export declare const and: {
     /**
      * Combines two predicates into a new predicate that returns `true` if both of the predicates returns `true`.
      *
-     * @param self - A predicate.
-     * @param that - A predicate.
-     *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate } from "effect"
      *
      * const minLength = (n: number) => (s: string) => s.length >= n
@@ -1296,6 +1216,7 @@ export declare const eqv: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Predicate } from "effect"
  *
  * type Triple = {
@@ -1343,6 +1264,7 @@ export declare const implies: {
      *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate } from "effect"
      *
      * type Triple = {
@@ -1390,6 +1312,7 @@ export declare const implies: {
      *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { Predicate } from "effect"
      *
      * type Triple = {