effect 4.0.0-beta.102 → 4.0.0-beta.103

package/dist/Schema.d.ts

@@ -17,7 +17,6 @@ import * as BigDecimal_ from "./BigDecimal.ts";
 import type * as Brand from "./Brand.ts";
 import * as Cause_ from "./Cause.ts";
 import * as Chunk_ from "./Chunk.ts";
-import type * as Combiner from "./Combiner.ts";
 import * as DateTime from "./DateTime.ts";
 import type { Differ } from "./Differ.ts";
 import * as Duration_ from "./Duration.ts";
@@ -299,8 +298,8 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<C
  *
  * **Example** (Schema for a parametric `Box<A>` type)
  *
- * ```ts
- * import { Effect, Option, Schema, SchemaIssue as Issue, SchemaParser } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Schema, SchemaIssue as Issue, SchemaParser } from "effect"
  *
  * interface Box<A> {
  *   readonly value: A
@@ -315,7 +314,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<C
  *     ([itemCodec]) =>
  *       (u, ast, options) => {
  *         if (!isBox(u)) {
- *           return Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(u)))
+ *           return Effect.fail(new SchemaIssue.InvalidType(ast))
  *         }
  *         return Effect.map(
  *           SchemaParser.decodeUnknownEffect(itemCodec)(u.value, options),
@@ -325,6 +324,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<C
  *   )
  *
  * const schema = Box(Schema.Number)
+ * Effect.runSync(Schema.decodeUnknownEffect(schema)({ value: 1 })) // => { value: 1 }
  * ```
  *
  * @category constructors
@@ -352,7 +352,7 @@ export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [
  *
  * **Example** (Defining a schema for a custom `UserId` branded type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * type UserId = string & { readonly _tag: "UserId" }
@@ -364,6 +364,7 @@ export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [
  *   title: "UserId",
  *   description: "A user identifier starting with 'user_'"
  * })
+ * Schema.decodeUnknownSync(UserId)("user_123") // => "user_123"
  * ```
  *
  * @see {@link declareConstructor} for creating schemas for parametric types.
@@ -384,7 +385,7 @@ export declare function declare<T, Iso = T>(is: (u: unknown) => u is T, annotati
  *
  * **Example** (Inspecting all type parameters of a schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.String
@@ -414,7 +415,7 @@ export declare function revealBottom<S extends Top>(bottom: S): Bottom<S["Type"]
  *
  * **Example** (Adding a title and description)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const Age = Schema.Natural.pipe(
@@ -423,6 +424,7 @@ export declare function revealBottom<S extends Top>(bottom: S): Bottom<S["Type"]
  *     description: "A non-negative integer representing age in years"
  *   })
  * )
+ * Schema.resolveAnnotations(Age)?.title // => "Age"
  * ```
  *
  * @see {@link annotateEncoded} to annotate the encoded side instead.
@@ -443,7 +445,7 @@ export declare function annotate<S extends Top>(annotations: Annotations.Bottom<
  *
  * **Example** (Adding a title to the encoded representation)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.NumberFromString.pipe(
@@ -452,8 +454,7 @@ export declare function annotate<S extends Top>(annotations: Annotations.Bottom<
  *   })
  * )
  *
- * console.log(Schema.toEncoded(schema).ast.annotations?.title)
- * // "my title"
+ * Schema.toEncoded(schema).ast.annotations?.title // => "my title"
  * ```
  *
  * @see {@link annotate} to annotate the type side instead.
@@ -476,7 +477,7 @@ export declare function annotateEncoded<S extends Top>(annotations: Annotations.
  *
  * **Example** (Customizing the missing-key message for a required field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Struct({
@@ -487,6 +488,7 @@ export declare function annotateEncoded<S extends Top>(annotations: Annotations.
  *     })
  *   )
  * })
+ * schema.fields.username.ast.context?.annotations?.messageMissingKey // => "Username is required"
  * ```
  *
  * @category annotations
@@ -640,7 +642,7 @@ export declare namespace Schema {
      *
      * **Example** (Extracting the decoded type)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
@@ -670,13 +672,13 @@ export declare namespace Schema {
  *
  * **Example** (Accepting any schema decoding to `string`)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
- * declare function print(schema: Schema.Schema<string>): void
+ * const accept = (_schema: Schema.Schema<string>): void => {}
  *
- * print(Schema.String)            // ok
- * print(Schema.NonEmptyString)    // ok
+ * accept(Schema.String)
+ * accept(Schema.NonEmptyString)
  * ```
  *
  * @see {@link Codec} — also tracks Encoded, DecodingServices, EncodingServices
@@ -700,7 +702,7 @@ export declare namespace Codec {
      *
      * **Example** (Extracting the encoded type)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * const schema = Schema.NumberFromString
@@ -719,7 +721,7 @@ export declare namespace Codec {
      *
      * **Example** (Checking decoding service requirements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * const schema = Schema.String
@@ -738,7 +740,7 @@ export declare namespace Codec {
      *
      * **Example** (Checking encoding service requirements)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * const schema = Schema.String
@@ -770,12 +772,13 @@ export declare namespace Codec {
  *
  * **Example** (Accepting a codec that decodes to `number` from `string`)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
- * declare function serialize<T>(codec: Schema.Codec<T, string>): string
+ * const serialize = <T>(codec: Schema.Codec<T, string>, value: T): string =>
+ *   Schema.encodeSync(codec)(value)
  *
- * serialize(Schema.NumberFromString) // ok — decodes number, encoded as string
+ * serialize(Schema.NumberFromString, 42) // => "42"
  * ```
  *
  * @see {@link Codec.Encoded} — extract the encoded type
@@ -848,7 +851,7 @@ export interface Encoder<out E, out RE = never> extends Schema<unknown> {
  *
  * **Example** (Recovering encoded type from a schema variable)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema: Schema.Schema<number> = Schema.NumberFromString
@@ -890,18 +893,14 @@ export {
 /**
  * Returns `true` if `u` is a {@link SchemaError}.
  *
- * **Example** (Narrowing Schema errors in a catch block)
+ * **Example** (Narrowing Schema errors)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Result, Schema } from "effect"
  *
- * try {
- *   Schema.decodeUnknownSync(Schema.Number)("oops")
- * } catch (err) {
- *   if (Schema.isSchemaError(err)) {
- *     console.log(err._tag) // "SchemaError"
- *   }
- * }
+ * const result = Result.try(() => Schema.decodeUnknownSync(Schema.Number)("oops"))
+ * const error: unknown = Result.isFailure(result) ? result.failure : undefined
+ * Schema.isSchemaError(error) // => true
  * ```
  *
  * @category guards
@@ -915,25 +914,22 @@ isSchemaError,
  * **Details**
  *
  * The `issue` field contains a structured {@link SchemaIssue.Issue} tree describing
- * every validation failure, including the path to the problematic value,
- * expected types, and actual values received. `message` renders the issue tree
- * as a human-readable string.
+ * every validation failure, including the path to the problematic value and
+ * the expected type or constraint. Built-in issues have no `actual` field,
+ * and built-in messages do not include the rejected value. Other Issue fields
+ * and custom annotations or messages are not sanitized. `message` renders the
+ * issue tree as a human-readable string.
  *
  * Use {@link isSchemaError} to narrow an unknown value to `SchemaError`.
  *
- * **Example** (Catching a SchemaError)
+ * **Example** (Inspecting a SchemaError)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Result, Schema } from "effect"
  *
- * try {
- *   Schema.decodeUnknownSync(Schema.Number)("not a number")
- * } catch (err) {
- *   if (Schema.isSchemaError(err)) {
- *     console.log(err.message)
- *     // Expected number, actual "not a number"
- *   }
- * }
+ * const result = Schema.decodeUnknownResult(Schema.Number)("not a number")
+ * const message = Result.isFailure(result) ? result.failure.message : ""
+ * message // => "Expected number"
  * ```
  *
  * @category errors
@@ -953,7 +949,7 @@ SchemaError };
  *
  * **Example** (Creating a standard schema from a regular schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * // Define custom hook functions for error formatting
@@ -991,16 +987,21 @@ SchemaError };
  *   name: "Alice",
  *   age: 30
  * })
- * console.log(validResult) // { value: { name: "Alice", age: 30 } }
- *
  * const invalidResult = standardSchema["~standard"].validate({
  *   name: "",
  *   age: 200
  * })
- * console.log(invalidResult) // { issues: [{ path: ["name"], message: "..." }, { path: ["age"], message: "..." }] }
+ *
+ * if (validResult instanceof Promise || invalidResult instanceof Promise) {
+ *   throw new Error("Expected synchronous validation")
+ * }
+ * if ("value" in validResult) {
+ *   validResult.value // => { name: "Alice", age: 30 }
+ * }
+ * invalidResult.issues?.map((issue) => issue.path) // => [["name"], ["age"]]
  * ```
  *
- * @category Standard Schema
+ * @category converting
  * @since 4.0.0
  */
 export declare function toStandardSchemaV1<S extends ConstraintDecoder<unknown>>(self: S, options?: {
@@ -1015,7 +1016,7 @@ export declare function toStandardSchemaV1<S extends ConstraintDecoder<unknown>>
  *
  * https://github.com/standard-schema/standard-schema/pull/134
  *
- * @category Standard Schema
+ * @category converting
  * @since 4.0.0
  */
 export declare function toStandardJSONSchemaV1<S extends Constraint>(self: S): StandardJSONSchemaV1<S["Encoded"], S["Type"]> & S;
@@ -1037,19 +1038,19 @@ export declare function toStandardJSONSchemaV1<S extends Constraint>(self: S): S
  *
  * **Example** (Defining a basic type guard)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const isString = Schema.is(Schema.String)
  *
- * console.log(isString("hello")) // true
- * console.log(isString(42)) // false
+ * isString("hello") // => true
+ * isString(42) // => false
  *
  * // Type narrowing in action
  * const value: unknown = "hello"
  * if (isString(value)) {
  *   // value is now typed as string
- *   console.log(value.toUpperCase()) // "HELLO"
+ *   value.toUpperCase() // => "HELLO"
  * }
  * ```
  *
@@ -1079,21 +1080,23 @@ export declare const is: typeof SchemaParser.is;
  *
  * **Example** (Asserting and narrowing an input)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Schema, SchemaIssue } from "effect"
  *
  * const input: unknown = "hello"
  *
  * // This will pass silently (no return value) and narrow input to string
  * Schema.asserts(Schema.String, input)
- * console.log(input.toUpperCase())
+ * input.toUpperCase() // => "HELLO"
  *
  * // This will throw an error
  * try {
  *   const invalid: unknown = 123
  *   Schema.asserts(Schema.String, invalid)
  * } catch (error) {
- *   console.log("Non-string assertion failed as expected")
+ *   if (error instanceof Error) {
+ *     SchemaIssue.isIssue(error.cause) // => true
+ *   }
  * }
  * ```
  *
@@ -1399,19 +1402,12 @@ export declare const decodePromise: <S extends ConstraintDecoder<unknown>>(schem
  *
  * **Example** (Decoding with a transformation schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const NumberFromString = Schema.NumberFromString
  *
- * console.log(Schema.decodeUnknownSync(NumberFromString)("42"))
- * // Output: 42
- *
- * Schema.decodeUnknownSync(NumberFromString)("not a number")
- * // throws SchemaError: NumberFromString
- * //   └─ Encoded side transformation failure
- * //      └─ NumberFromString
- * //         └─ Expected a numeric string, actual "not a number"
+ * Schema.decodeUnknownSync(NumberFromString)("42") // => 42
  * ```
  *
  * @see {@link SchemaParser.decodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
@@ -1465,13 +1461,12 @@ export declare const decodeSync: <S extends ConstraintDecoder<unknown>>(schema:
  *
  * **Example** (Encoding a value to a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * const NumberFromString = Schema.NumberFromString
  *
- * Effect.runPromise(Schema.encodeUnknownEffect(NumberFromString)(42)).then(console.log)
- * // Output: "42"
+ * await Effect.runPromise(Schema.encodeUnknownEffect(NumberFromString)(42)) // => "42"
  * ```
  *
  * @see {@link SchemaParser.encodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
@@ -1833,7 +1828,7 @@ interface optionalKeyLambda extends Lambda {
  *
  * **Example** (Creating a struct with optional key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Struct({
@@ -1892,7 +1887,7 @@ interface optionalLambda extends Lambda {
  *
  * **Example** (Defining an optional field accepting undefined)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Struct({
@@ -2059,12 +2054,12 @@ export interface flip<S extends Top> extends BottomLazy<SchemaAST.AST, flip<S>,
  *
  * **Example** (Flipping a number-from-string schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * // NumberFromString: decodes string → number
  * const flipped = Schema.flip(Schema.NumberFromString)
- * // flipped: decodes number → string
+ * Schema.decodeSync(flipped)(42) // => "42"
  * ```
  *
  * @category transforming
@@ -2086,11 +2081,12 @@ export interface Literal<L extends SchemaAST.LiteralValue> extends Bottom<L, L,
  *
  * **Example** (Defining a string literal)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Literal("hello")
  * // Type: Schema.Literal<"hello">
+ * Schema.decodeSync(schema)("hello") // => "hello"
  * ```
  *
  * @see {@link Literals} for a schema that represents a union of literals.
@@ -2180,11 +2176,11 @@ export interface TemplateLiteral<Parts extends TemplateLiteral.Parts> extends Bo
  *
  * **Example** (Defining a URL path pattern)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.TemplateLiteral(["/user/", Schema.Number])
- * // matches strings like "/user/123", "/user/42", etc.
+ * Schema.is(schema)("/user/123") // => true
  * ```
  *
  * @see {@link TemplateLiteralParser} for a schema that also parses matched parts into a tuple.
@@ -2246,11 +2242,11 @@ export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> exte
  *
  * **Example** (Parsing path parameters)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.TemplateLiteralParser(["/user/", Schema.NumberFromString])
- * // decodes "/user/42" => readonly ["/user/", 42]
+ * Schema.decodeSync(schema)("/user/42") // => ["/user/", 42]
  * ```
  *
  * @see {@link TemplateLiteral} for a validation-only version that keeps the string encoded.
@@ -2274,7 +2270,7 @@ export interface Enum<A extends {
  *
  * **Example** (Defining a direction enum)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * enum Direction {
@@ -2283,7 +2279,7 @@ export interface Enum<A extends {
  * }
  *
  * const schema = Schema.Enum(Direction)
- * // accepts "Up" or "Down"
+ * Schema.decodeSync(schema)(Direction.Up) // => "Up"
  * ```
  *
  * @category constructors
@@ -2431,7 +2427,7 @@ export interface Boolean extends Bottom<boolean, boolean, never, never, SchemaAS
  *
  * @see {@link BooleanFromBit} for a schema that decodes bit literals `0` or `1` into a boolean
  *
- * @category boolean
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Boolean: Boolean;
@@ -2530,11 +2526,12 @@ export interface UniqueSymbol<sym extends symbol> extends Bottom<sym, sym, never
  *
  * **Example** (Defining a specific symbol)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const mySymbol = Symbol.for("mySymbol")
  * const schema = Schema.UniqueSymbol(mySymbol)
+ * Schema.decodeSync(schema)(mySymbol) === mySymbol // => true
  * ```
  *
  * @see {@link Symbol} for a schema that accepts any symbol.
@@ -2667,7 +2664,7 @@ export declare namespace Struct {
     type ReadonlyMakeIn<F extends Fields> = {
         readonly [K in keyof F]: F[K]["~type.make"];
     };
-    type MakeInView<F extends Fields, O extends keyof F = TypeOptionalKeys<F> | TypeConstructorDefaultedKeys<F>> = [O] extends [never] ? ReadonlyMakeIn<F> : Simplify<SetOptional<ReadonlyMakeIn<F>, O>>;
+    type MakeInView<F extends Fields, O extends keyof F = TypeOptionalKeys<F> | TypeConstructorDefaultedKeys<F>> = [O] extends [never] ? Simplify<ReadonlyMakeIn<F>> : Simplify<SetOptional<ReadonlyMakeIn<F>, O>>;
     /**
      * Computes the input object type accepted when constructing a struct value.
      *
@@ -2701,7 +2698,7 @@ export interface Struct<Fields extends Struct.Fields> extends BottomLazy<SchemaA
      *
      * **Example** (Reusing fields across structs)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * const Timestamped = Schema.Struct({
@@ -2714,6 +2711,7 @@ export interface Struct<Fields extends Struct.Fields> extends BottomLazy<SchemaA
      *   name: Schema.String,
      *   email: Schema.String
      * })
+     * Object.keys(User.fields) // => ["createdAt", "updatedAt", "name", "email"]
      * ```
      */
     readonly fields: Fields;
@@ -2750,7 +2748,7 @@ export interface Struct<Fields extends Struct.Fields> extends BottomLazy<SchemaA
  *
  * **Example** (Defining a basic struct)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const Person = Schema.Struct({
@@ -2762,9 +2760,7 @@ export interface Struct<Fields extends Struct.Fields> extends BottomLazy<SchemaA
  * // { readonly name: string; readonly age: number; readonly email?: string }
  * type Person = typeof Person.Type
  *
- * const alice = Schema.decodeUnknownSync(Person)({ name: "Alice", age: 30 })
- * console.log(alice)
- * // { name: 'Alice', age: 30 }
+ * Schema.decodeUnknownSync(Person)({ name: "Alice", age: 30 }) // => { name: "Alice", age: 30 }
  * ```
  *
  * @category constructors
@@ -2789,7 +2785,7 @@ interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
  *
  * **Example** (Adding fields to a union of structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, Tuple } from "effect"
  *
  * // Add a new field to all members of a union of structs
@@ -2797,6 +2793,7 @@ interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
  *   Schema.Struct({ a: Schema.String }),
  *   Schema.Struct({ b: Schema.Number })
  * ]).mapMembers(Tuple.map(Schema.fieldsAssign({ c: Schema.Number })))
+ * Schema.decodeSync(schema)({ a: "a", c: 1 }) // => { a: "a", c: 1 }
  * ```
  *
  * @category combinators
@@ -2830,16 +2827,14 @@ export interface encodeKeys<S extends Constraint & {
  *
  * **Example** (Renaming `name` to `full_name` in the encoded form)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
  * const Encoded = Person.pipe(Schema.encodeKeys({ name: "full_name" }))
  *
  * // Decodes { full_name: "Alice", age: 30 } → { name: "Alice", age: 30 }
- * const alice = Schema.decodeUnknownSync(Encoded)({ full_name: "Alice", age: 30 })
- * console.log(alice)
- * // { name: 'Alice', age: 30 }
+ * Schema.decodeUnknownSync(Encoded)({ full_name: "Alice", age: 30 }) // => { name: "Alice", age: 30 }
  * ```
  *
  * @category transforming
@@ -2862,7 +2857,7 @@ export declare function encodeKeys<S extends Constraint & {
  *
  * **Example** (Adding a computed `fullName` field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Schema } from "effect"
  *
  * const Person = Schema.Struct({ first: Schema.String, last: Schema.String })
@@ -2874,8 +2869,7 @@ export declare function encodeKeys<S extends Constraint & {
  * )
  *
  * const alice = Schema.decodeUnknownSync(Extended)({ first: "Alice", last: "Smith" })
- * console.log(alice.fullName)
- * // Alice Smith
+ * alice.fullName // => "Alice Smith"
  * ```
  *
  * @category transforming
@@ -3067,9 +3061,16 @@ export interface $Record<Key extends Record.Key, Value extends Constraint> exten
  * For transformed key schemas, property selection is based on encoded property
  * names before the selected key is decoded.
  *
+ * **Gotchas**
+ *
+ * When decoded or encoded key transformations produce the same property key,
+ * sequential parsing applies selected own properties in selection order, so
+ * the later selected property overwrites the earlier value. With concurrency
+ * greater than `1`, completion order determines which value is retained.
+ *
  * **Example** (Defining a string-keyed record of numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Record(Schema.String, Schema.Number)
@@ -3077,20 +3078,13 @@ export interface $Record<Key extends Record.Key, Value extends Constraint> exten
  * // { readonly [x: string]: number }
  * type R = typeof schema.Type
  *
- * const result = Schema.decodeUnknownSync(schema)({ a: 1, b: 2 })
- * console.log(result)
- * // { a: 1, b: 2 }
+ * Schema.decodeUnknownSync(schema)({ a: 1, b: 2 }) // => { a: 1, b: 2 }
  * ```
  *
  * @category constructors
  * @since 3.10.0
  */
-export declare function Record<Key extends Record.Key, Value extends Constraint>(key: Key, value: Value, options?: {
-    readonly keyValueCombiner: {
-        readonly decode?: Combiner.Combiner<readonly [Key["Type"], Value["Type"]]> | undefined;
-        readonly encode?: Combiner.Combiner<readonly [Key["Encoded"], Value["Encoded"]]> | undefined;
-    };
-}): $Record<Key, Value>;
+export declare function Record<Key extends Record.Key, Value extends Constraint>(key: Key, value: Value): $Record<Key, Value>;
 /**
  * Namespace for `StructWithRest` type utilities.
  *
@@ -3194,7 +3188,7 @@ export declare namespace StructWithRest {
      *
      * **Example** (Checking record compatibility)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * const user = Schema.Struct({ id: Schema.String })
@@ -3251,7 +3245,7 @@ export interface StructWithRest<S extends StructWithRest.Objects, Records extend
  *
  * **Example** (Defining structs with string-indexed extra keys)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.StructWithRest(
@@ -3411,14 +3405,12 @@ export interface Tuple<Elements extends Tuple.Elements> extends BottomLazy<Schem
  *
  * **Example** (Defining a pair of string and number)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Tuple([Schema.String, Schema.Number])
  *
- * const pair = Schema.decodeUnknownSync(schema)(["hello", 42])
- * console.log(pair)
- * // [ 'hello', 42 ]
+ * Schema.decodeUnknownSync(schema)(["hello", 42]) // => ["hello", 42]
  * ```
  *
  * @category constructors
@@ -3571,7 +3563,7 @@ export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends T
  *
  * **Example** (Defining tuples with rest elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * // [string, number, ...boolean[]]
@@ -3580,9 +3572,7 @@ export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends T
  *   [Schema.Boolean]
  * )
  *
- * const result = Schema.decodeUnknownSync(schema)(["hello", 1, true, false])
- * console.log(result)
- * // [ 'hello', 1, true, false ]
+ * Schema.decodeUnknownSync(schema)(["hello", 1, true, false]) // => ["hello", 1, true, false]
  * ```
  *
  * @category constructors
@@ -3620,14 +3610,12 @@ export {
  *
  * **Example** (Defining an array of strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Array(Schema.String)
  *
- * const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
- * console.log(result)
- * // [ 'a', 'b', 'c' ]
+ * Schema.decodeUnknownSync(schema)(["a", "b", "c"]) // => ["a", "b", "c"]
  * ```
  *
  * @category constructors
@@ -3660,13 +3648,12 @@ interface NonEmptyArrayLambda extends Lambda {
  *
  * **Example** (Defining a non-empty array of numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.NonEmptyArray(Schema.Number)
  *
- * Schema.decodeUnknownSync(schema)([1, 2, 3])  // ok
- * Schema.decodeUnknownSync(schema)([])          // throws
+ * Schema.decodeUnknownSync(schema)([1, 2, 3]) // => [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -3761,13 +3748,16 @@ interface mutableLambda extends Lambda {
  *
  * **Example** (Defining mutable arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.mutable(Schema.Array(Schema.Number))
  *
  * // number[]   (mutable)
  * type T = typeof schema.Type
+ * const value: T = [1, 2]
+ * value.push(3)
+ * value // => [1, 2, 3]
  * ```
  *
  * @category transforming
@@ -3837,13 +3827,13 @@ export interface Union<Members extends ReadonlyArray<Constraint>> extends Bottom
  *
  * **Example** (Defining a string or number union)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Union([Schema.String, Schema.Number])
  *
- * Schema.decodeUnknownSync(schema)("hello") // "hello"
- * Schema.decodeUnknownSync(schema)(42)       // 42
+ * Schema.decodeUnknownSync(schema)("hello") // => "hello"
+ * Schema.decodeUnknownSync(schema)(42) // => 42
  * ```
  *
  * @category constructors
@@ -3879,11 +3869,11 @@ export interface Literals<L extends ReadonlyArray<SchemaAST.LiteralValue>> exten
  *
  * **Example** (Defining status codes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Literals(["active", "inactive", "pending"])
- * // accepts "active", "inactive", or "pending"
+ * Schema.decodeSync(schema)("active") // => "active"
  * ```
  *
  * @see {@link Literal} for a schema that represents a single literal.
@@ -3973,7 +3963,7 @@ export interface suspend<S extends Constraint> extends BottomLazy<SchemaAST.Susp
  *
  * **Example** (Defining recursive tree schemas)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * interface Tree {
@@ -3985,6 +3975,7 @@ export interface suspend<S extends Constraint> extends BottomLazy<SchemaAST.Susp
  *   value: Schema.Number,
  *   children: Schema.Array(Schema.suspend((): Schema.Codec<Tree> => Tree))
  * })
+ * Schema.decodeSync(Tree)({ value: 1, children: [] }) // => { value: 1, children: [] }
  * ```
  *
  * @category constructors
@@ -3997,12 +3988,14 @@ export declare function suspend<S extends Constraint>(f: () => S): suspend<S>;
  *
  * **Example** (Adding checks to a schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const AgeSchema = Schema.Finite.pipe(
  *   Schema.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(120))
  * )
+ * Schema.is(AgeSchema)(42) // => true
+ * Schema.is(AgeSchema)(121) // => false
  * ```
  *
  * @category filtering
@@ -4116,14 +4109,17 @@ export interface middlewareDecoding<S extends Constraint, RD> extends BottomLazy
  *
  * **Example** (Logging decode failures)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
+ * const events: Array<string> = []
  * const Logged = Schema.String.pipe(
  *   Schema.middlewareDecoding((effect) =>
- *     Effect.tapError(effect, (issue) => Effect.log("decode failed", issue))
+ *     Effect.tapError(effect, () => Effect.sync(() => events.push("decode failed")))
  *   )
  * )
+ * Effect.runSync(Effect.result(Schema.decodeUnknownEffect(Logged)(42)))
+ * events // => ["decode failed"]
  * ```
  *
  * @see {@link catchDecoding} for a simpler error-recovery variant
@@ -4158,14 +4154,17 @@ export interface middlewareEncoding<S extends Constraint, RE> extends BottomLazy
  *
  * **Example** (Logging encode failures)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
+ * const events: Array<string> = []
  * const Logged = Schema.String.pipe(
  *   Schema.middlewareEncoding((effect) =>
- *     Effect.tapError(effect, (issue) => Effect.log("encode failed", issue))
+ *     Effect.tapError(effect, () => Effect.sync(() => events.push("encode failed")))
  *   )
  * )
+ * Effect.runSync(Effect.result(Schema.encodeUnknownEffect(Logged)(42)))
+ * events // => ["encode failed"]
  * ```
  *
  * @see {@link catchEncoding} for a simpler error-recovery variant
@@ -4183,12 +4182,13 @@ export declare function middlewareEncoding<S extends Constraint, RE>(encode: (ef
  *
  * **Example** (Returning a default on decode failure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Option, Schema } from "effect"
  *
  * const schema = Schema.Number.pipe(
  *   Schema.catchDecoding((_issue) => Effect.succeed(Option.some(0)))
  * )
+ * Effect.runSync(Schema.decodeUnknownEffect(schema)("invalid")) // => 0
  * ```
  *
  * @see {@link catchDecodingWithContext} to add service requirements to the handler
@@ -4304,7 +4304,7 @@ export interface compose<To extends Constraint, From extends Constraint> extends
  *
  * **Example** (Transforming strings to numbers with a schema transformation)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaGetter } from "effect"
  *
  * const NumberFromString = Schema.String.pipe(
@@ -4317,8 +4317,7 @@ export interface compose<To extends Constraint, From extends Constraint> extends
  *   )
  * )
  *
- * const result = Schema.decodeUnknownSync(NumberFromString)("123")
- * // result: 123
+ * Schema.decodeUnknownSync(NumberFromString)("123") // => 123
  * ```
  *
  * @category transforming
@@ -4355,7 +4354,7 @@ export declare function decodeTo<To extends Constraint, From extends Constraint,
  *
  * **Example** (Trimming string values during encoding/decoding)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaGetter } from "effect"
  *
  * const Trimmed = Schema.String.pipe(
@@ -4365,8 +4364,7 @@ export declare function decodeTo<To extends Constraint, From extends Constraint,
  *   })
  * )
  *
- * const result = Schema.decodeUnknownSync(Trimmed)("  hello  ")
- * // result: "hello"
+ * Schema.decodeUnknownSync(Trimmed)("  hello  ") // => "hello"
  * ```
  *
  * @category transforming
@@ -4391,7 +4389,7 @@ export declare function decode<S extends Constraint, RD = never, RE = never>(tra
  *
  * **Example** (Encoding a number back to a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaGetter } from "effect"
  *
  * const NumberFromString = Schema.Number.pipe(
@@ -4400,6 +4398,7 @@ export declare function decode<S extends Constraint, RD = never, RE = never>(tra
  *     encode: SchemaGetter.transform((n: number) => String(n))
  *   })
  * )
+ * Schema.decodeSync(NumberFromString)("42") // => 42
  * ```
  *
  * @category transforming
@@ -4421,7 +4420,7 @@ export declare function encodeTo<To extends Constraint, From extends Constraint,
  *
  * **Example** (Upper-casing encoded strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaGetter } from "effect"
  *
  * const UpperFromLower = Schema.String.pipe(
@@ -4430,6 +4429,7 @@ export declare function encodeTo<To extends Constraint, From extends Constraint,
  *     encode: SchemaGetter.transform((s: string) => s.toUpperCase())
  *   })
  * )
+ * Schema.encodeSync(UpperFromLower)("hello") // => "HELLO"
  * ```
  *
  * @category transforming
@@ -4478,7 +4478,7 @@ export interface withConstructorDefault<S extends Constraint & WithoutConstructo
  *
  * **Example** (Defining an optional field with a static default)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
@@ -4488,8 +4488,7 @@ export interface withConstructorDefault<S extends Constraint & WithoutConstructo
  *   )
  * })
  *
- * const value = MySchema.make({})
- * // value: { name: "anonymous" }
+ * MySchema.make({}).name // => "anonymous"
  * ```
  *
  * @category constructors
@@ -4538,15 +4537,14 @@ export type DecodingDefaultOptions = {
  *
  * **Example** (Providing a default for a missing struct key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
  *   name: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed("anonymous")))
  * })
  *
- * const result = Schema.decodeUnknownSync(MySchema)({})
- * // result: { name: "anonymous" }
+ * Schema.decodeUnknownSync(MySchema)({}).name // => "anonymous"
  * ```
  *
  * @see {@link withDecodingDefault} for the value-level variant (key absent **or** `undefined`)
@@ -4619,15 +4617,14 @@ export interface withDecodingDefault<S extends Constraint, R = never> extends de
  *
  * **Example** (Providing a default for an optional field value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
  *   name: Schema.String.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed("anonymous")))
  * })
  *
- * const result = Schema.decodeUnknownSync(MySchema)({ name: undefined })
- * // result: { name: "anonymous" }
+ * Schema.decodeUnknownSync(MySchema)({ name: undefined }).name // => "anonymous"
  * ```
  *
  * @see {@link withDecodingDefaultKey} for the key-level variant (key absent only, not `undefined`)
@@ -4688,14 +4685,14 @@ export interface tag<Tag extends SchemaAST.LiteralValue> extends withConstructor
  *
  * **Example** (Defining a discriminated union tag)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const A = Schema.Struct({ _tag: Schema.tag("A"), value: Schema.Number })
  *
  * // _tag is optional in make, auto-filled to "A"
  * const a = A.make({ value: 42 })
- * // a: { _tag: "A", value: 42 }
+ * a // => { _tag: "A", value: 42 }
  * ```
  *
  * @see {@link tagDefaultOmit} to also omit the tag during encoding
@@ -4719,7 +4716,7 @@ export declare function tag<Tag extends SchemaAST.LiteralValue>(literal: Tag): t
  *
  * **Example** (Omitting tags during encoding)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const A = Schema.Struct({
@@ -4728,8 +4725,7 @@ export declare function tag<Tag extends SchemaAST.LiteralValue>(literal: Tag): t
  * })
  *
  * // Encode strips the _tag field
- * const encoded = Schema.encodeUnknownSync(A)({ _tag: "A", value: 1 })
- * // encoded: { value: 1 }
+ * Schema.encodeUnknownSync(A)({ _tag: "A", value: 1 }) // => { value: 1 }
  * ```
  *
  * @see {@link tag} for the variant that keeps the tag during encoding
@@ -4761,7 +4757,7 @@ export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends Stru
  *
  * **Example** (Defining a tagged struct shorthand)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * // Defines a struct with a fixed `_tag` field
@@ -4774,19 +4770,20 @@ export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends Stru
  *   _tag: Schema.tag("A"),
  *   a: Schema.String
  * })
+ * void tagged
+ * void equivalent
  * ```
  *
  * **Example** (Accessing the literal value of the tag)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const tagged = Schema.TaggedStruct("A", {
  *   a: Schema.String
  * })
  *
- * // literal: "A"
- * const literal = tagged.fields._tag.schema.literal
+ * tagged.fields._tag.schema.literal // => "A"
  * ```
  *
  * @category constructors
@@ -4851,7 +4848,7 @@ export type toTaggedUnion<Tag extends PropertyKey, Members extends ReadonlyArray
  *
  * **Example** (Adding tagged-union utilities to an existing union)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const A = Schema.TaggedStruct("A", { value: Schema.Number })
@@ -4864,6 +4861,7 @@ export type toTaggedUnion<Tag extends PropertyKey, Members extends ReadonlyArray
  *   A: (a) => `number: ${a.value}`,
  *   B: (b) => `name: ${b.name}`
  * })
+ * result // => "number: 1"
  * ```
  *
  * @see {@link TaggedUnion} for a shorthand that builds the union from scratch
@@ -4924,7 +4922,7 @@ export interface TaggedUnion<Cases extends Record<string, Constraint>> extends B
  *
  * **Example** (Pattern matching a discriminated union)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const Shape = Schema.TaggedUnion({
@@ -4937,6 +4935,7 @@ export interface TaggedUnion<Cases extends Record<string, Constraint>> extends B
  *   Circle: (c) => Math.PI * c.radius ** 2,
  *   Rectangle: (r) => r.width * r.height
  * })
+ * Math.round(area * 100) / 100 // => 78.54
  * ```
  *
  * @see {@link toTaggedUnion} to augment an existing union instead
@@ -4969,7 +4968,7 @@ export interface Opaque<Self, S extends Top, Brand> extends BottomLazyWithoutNew
  *
  * **Example** (Defining opaque structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * class Person extends Schema.Opaque<Person>()(
@@ -4980,7 +4979,7 @@ export interface Opaque<Self, S extends Top, Brand> extends BottomLazyWithoutNew
  *
  * // Decoded value is Person, not { name: string }
  * const person = Schema.decodeUnknownSync(Person)({ name: "Alice" })
- * // person: Person
+ * person.name // => "Alice"
  * ```
  *
  * @category constructors
@@ -5002,13 +5001,13 @@ export interface instanceOf<T, Iso = T> extends declare<T, Iso> {
  *
  * **Example** (Defining a schema for a built-in class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const DateSchema = Schema.instanceOf(Date)
  *
  * const decoded = Schema.decodeUnknownSync(DateSchema)(new Date("2024-01-01"))
- * // decoded: Date
+ * decoded.toISOString() // => "2024-01-01T00:00:00.000Z"
  * ```
  *
  * @category constructors
@@ -5042,8 +5041,8 @@ export declare function link<T>(): <To extends Constraint>(encodeTo: To, transfo
  *
  * **Example** (Reporting failure at a nested path)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Result, Schema } from "effect"
  *
  * const schema = Schema.Struct({ password: Schema.String, confirmPassword: Schema.String }).check(
  *   Schema.makeFilter((o) =>
@@ -5053,15 +5052,16 @@ export declare function link<T>(): <To extends Constraint>(encodeTo: To, transfo
  *   )
  * )
  *
- * console.log(String(Schema.decodeUnknownExit(schema)({ password: "123456", confirmPassword: "1234567" })))
- * // Failure(Cause([Fail(SchemaError: password and confirmPassword must match
- * //   at ["password"])]))
+ * const result = Schema.decodeUnknownResult(schema)({ password: "123456", confirmPassword: "1234567" })
+ * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Pointer") {
+ *   result.failure.issue.issue.path // => ["password"]
+ * }
  * ```
  *
  * **Example** (Reporting multiple failures at once)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Result, Schema } from "effect"
  *
  * const schema = Schema.Struct({ a: Schema.Finite, b: Schema.Finite, c: Schema.Finite }).check(
  *   Schema.makeFilter((o) => {
@@ -5074,11 +5074,10 @@ export declare function link<T>(): <To extends Constraint>(encodeTo: To, transfo
  *   })
  * )
  *
- * console.log(String(Schema.decodeUnknownExit(schema)({ a: 1, b: 0, c: 0 })))
- * // Failure(Cause([Fail(SchemaError: b must be greater than 0
- * //   at ["b"]
- * // c must be greater than 0
- * //   at ["c"])]))
+ * const result = Schema.decodeUnknownResult(schema)({ a: 1, b: 0, c: 0 })
+ * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Composite") {
+ *   result.failure.issue.issue.issues.map((issue) => issue._tag === "Pointer" ? issue.path : []) // => [["b"], ["c"]]
+ * }
  * ```
  *
  * @category constructors
@@ -5092,8 +5091,8 @@ export declare const makeFilter: <T>(filter: (input: T, ast: SchemaAST.AST, opti
  * **Details**
  *
  * - `string`: failure with that string as the message. Produces an
- *   {@link SchemaIssue.InvalidValue} wrapping the input, with the string used as
- *   the issue's `message` annotation.
+ *   {@link SchemaIssue.InvalidValue} with the string used as the issue's
+ *   `message` annotation.
  * - {@link SchemaIssue.Issue}: a fully-formed issue, returned as-is.
  * - `{ path, issue }`: failure attached to a nested path. `issue` is either
  *   a `string` (wrapped in an {@link SchemaIssue.InvalidValue}) or a full
@@ -5118,8 +5117,8 @@ export type FilterIssue = string | SchemaIssue.Issue | {
  * - `undefined`: success. The input satisfies the filter.
  * - `true`: success. Equivalent to `undefined`, useful when the predicate is
  *   a plain boolean expression.
- * - `false`: generic failure. Produces an {@link SchemaIssue.InvalidValue} wrapping
- *   the input, with no custom message.
+ * - `false`: generic failure. Produces an {@link SchemaIssue.InvalidValue}
+ *   with no custom message.
  * - {@link FilterIssue}: a single failure. See {@link FilterIssue} for the
  *   shapes (`string`, {@link SchemaIssue.Issue}, or `{ path, issue }`).
  * - `ReadonlyArray<FilterIssue>`: several failures reported together. An
@@ -5154,7 +5153,7 @@ export declare function makeFilterGroup<T>(checks: readonly [SchemaAST.Check<T>,
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the trimmed pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isTrimmed(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5167,7 +5166,7 @@ export declare function isTrimmed(annotations?: Annotations.Filter): SchemaAST.F
  *
  * @see {@link isTrimmed} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isTrimmedReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5185,7 +5184,7 @@ export declare const isTrimmedReviver: SchemaRepresentation.FilterReviver<null>;
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the specified RegExp pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isPattern(regExp: globalThis.RegExp, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5198,7 +5197,7 @@ export declare function isPattern(regExp: globalThis.RegExp, annotations?: Annot
  *
  * @see {@link isPattern} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isPatternReviver: SchemaRepresentation.FilterReviver<{
@@ -5220,7 +5219,7 @@ export declare const isPatternReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the number string pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isStringFinite(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5233,7 +5232,7 @@ export declare function isStringFinite(annotations?: Annotations.Filter): Schema
  *
  * @see {@link isStringFinite} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isStringFiniteReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5251,7 +5250,7 @@ export declare const isStringFiniteReviver: SchemaRepresentation.FilterReviver<n
  * This check corresponds to a `pattern` constraint with the same signed
  * base-10 integer pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isStringBigInt(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5264,7 +5263,7 @@ export declare function isStringBigInt(annotations?: Annotations.Filter): Schema
  *
  * @see {@link isStringBigInt} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isStringBigIntReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5277,7 +5276,7 @@ export declare const isStringBigIntReviver: SchemaRepresentation.FilterReviver<n
  * The check uses the pattern `^Symbol\((.*)\)$`. It is not a general test for
  * whether a string can be passed to JavaScript's `Symbol()` function.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isStringSymbol(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5290,7 +5289,7 @@ export declare function isStringSymbol(annotations?: Annotations.Filter): Schema
  *
  * @see {@link isStringSymbol} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isStringSymbolReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5321,7 +5320,7 @@ export declare const isStringSymbolReviver: SchemaRepresentation.FilterReviver<n
  * constraint to ensure generated strings match the UUID pattern.
  *
  * @see {@link isGUID} for shape-only GUID validation.
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5334,7 +5333,7 @@ export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotati
  *
  * @see {@link isUUID} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isUUIDReviver: SchemaRepresentation.FilterReviver<{
@@ -5361,7 +5360,7 @@ export declare const isUUIDReviver: SchemaRepresentation.FilterReviver<{
  * constraint to ensure generated strings match the GUID pattern.
  *
  * @see {@link isUUID} for strict UUID validation.
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isGUID(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5374,7 +5373,7 @@ export declare function isGUID(annotations?: Annotations.Filter): SchemaAST.Filt
  *
  * @see {@link isGUID} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGUIDReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5394,7 +5393,7 @@ export declare const isGUIDReviver: SchemaRepresentation.FilterReviver<null>;
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the ULID pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isULID(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5407,7 +5406,7 @@ export declare function isULID(annotations?: Annotations.Filter): SchemaAST.Filt
  *
  * @see {@link isULID} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isULIDReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5426,7 +5425,7 @@ export declare const isULIDReviver: SchemaRepresentation.FilterReviver<null>;
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the Base64 pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isBase64(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5439,7 +5438,7 @@ export declare function isBase64(annotations?: Annotations.Filter): SchemaAST.Fi
  *
  * @see {@link isBase64} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBase64Reviver: SchemaRepresentation.FilterReviver<null>;
@@ -5459,7 +5458,7 @@ export declare const isBase64Reviver: SchemaRepresentation.FilterReviver<null>;
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the Base64URL pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isBase64Url(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5472,7 +5471,7 @@ export declare function isBase64Url(annotations?: Annotations.Filter): SchemaAST
  *
  * @see {@link isBase64Url} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBase64UrlReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5484,7 +5483,7 @@ export declare const isBase64UrlReviver: SchemaRepresentation.FilterReviver<null
  * RegExp metacharacters in the prefix are escaped in JSON Schema and arbitrary
  * metadata so that the generated patterns retain literal `startsWith` semantics.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isStartsWith(startsWith: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5497,7 +5496,7 @@ export declare function isStartsWith(startsWith: string, annotations?: Annotatio
  *
  * @see {@link isStartsWith} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isStartsWithReviver: SchemaRepresentation.FilterReviver<{
@@ -5511,7 +5510,7 @@ export declare const isStartsWithReviver: SchemaRepresentation.FilterReviver<{
  * RegExp metacharacters in the suffix are escaped in JSON Schema and arbitrary
  * metadata so that the generated patterns retain literal `endsWith` semantics.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isEndsWith(endsWith: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5524,7 +5523,7 @@ export declare function isEndsWith(endsWith: string, annotations?: Annotations.F
  *
  * @see {@link isEndsWith} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isEndsWithReviver: SchemaRepresentation.FilterReviver<{
@@ -5539,7 +5538,7 @@ export declare const isEndsWithReviver: SchemaRepresentation.FilterReviver<{
  * arbitrary metadata so that the generated patterns retain literal `includes`
  * semantics.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isIncludes(includes: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5552,7 +5551,7 @@ export declare function isIncludes(includes: string, annotations?: Annotations.F
  *
  * @see {@link isIncludes} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isIncludesReviver: SchemaRepresentation.FilterReviver<{
@@ -5567,7 +5566,7 @@ export declare const isIncludesReviver: SchemaRepresentation.FilterReviver<{
  * such as digits, punctuation, and whitespace. It rejects strings that would
  * change when uppercased.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isUppercased(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5580,7 +5579,7 @@ export declare function isUppercased(annotations?: Annotations.Filter): SchemaAS
  *
  * @see {@link isUppercased} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isUppercasedReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5593,7 +5592,7 @@ export declare const isUppercasedReviver: SchemaRepresentation.FilterReviver<nul
  * such as digits, punctuation, and whitespace. It rejects strings that would
  * change when lowercased.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isLowercased(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5606,7 +5605,7 @@ export declare function isLowercased(annotations?: Annotations.Filter): SchemaAS
  *
  * @see {@link isLowercased} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLowercasedReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5619,7 +5618,7 @@ export declare const isLowercasedReviver: SchemaRepresentation.FilterReviver<nul
  * Empty strings pass. Strings whose first character has no lowercase form, such
  * as a digit, punctuation mark, or whitespace, also pass.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isCapitalized(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5632,7 +5631,7 @@ export declare function isCapitalized(annotations?: Annotations.Filter): SchemaA
  *
  * @see {@link isCapitalized} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isCapitalizedReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5645,7 +5644,7 @@ export declare const isCapitalizedReviver: SchemaRepresentation.FilterReviver<nu
  * Empty strings pass. Strings whose first character has no uppercase form, such
  * as a digit, punctuation mark, or whitespace, also pass.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isUncapitalized(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
@@ -5658,14 +5657,14 @@ export declare function isUncapitalized(annotations?: Annotations.Filter): Schem
  *
  * @see {@link isUncapitalized} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isUncapitalizedReviver: SchemaRepresentation.FilterReviver<null>;
 /**
  * Type-level representation of {@link Finite}.
  *
- * @category Number
+ * @category models
  * @since 3.10.0
  */
 export interface Finite extends Number {
@@ -5674,7 +5673,7 @@ export interface Finite extends Number {
 /**
  * Schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.
  *
- * @category Number
+ * @category schemas
  * @since 3.10.0
  */
 export declare const Finite: Finite;
@@ -5693,7 +5692,7 @@ export declare const Finite: Finite;
  * When generating test data with fast-check, this applies `noNaN: true` and
  * `noInfinity: true` constraints to ensure generated numbers are finite.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isFinite: (annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
@@ -5706,7 +5705,7 @@ export declare const isFinite: (annotations?: Annotations.Filter) => SchemaAST.F
  *
  * @see {@link isFinite} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isFiniteReviver: SchemaRepresentation.FilterReviver<null>;
@@ -5714,7 +5713,7 @@ export declare const isFiniteReviver: SchemaRepresentation.FilterReviver<null>;
  * Creates a greater-than (`>`) check for any ordered type from an
  * `Order.Order` instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function makeIsGreaterThan<T>(options: {
@@ -5726,7 +5725,7 @@ export declare function makeIsGreaterThan<T>(options: {
  * Creates a greater-than-or-equal-to (`>=`) check for any ordered type from an
  * `Order.Order` instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function makeIsGreaterThanOrEqualTo<T>(options: {
@@ -5738,7 +5737,7 @@ export declare function makeIsGreaterThanOrEqualTo<T>(options: {
  * Creates a less-than (`<`) check for any ordered type from an `Order.Order`
  * instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function makeIsLessThan<T>(options: {
@@ -5750,7 +5749,7 @@ export declare function makeIsLessThan<T>(options: {
  * Creates a less-than-or-equal-to (`<=`) check for any ordered type from an
  * `Order.Order` instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function makeIsLessThanOrEqualTo<T>(options: {
@@ -5762,7 +5761,7 @@ export declare function makeIsLessThanOrEqualTo<T>(options: {
  * Creates an inclusive or exclusive range check for any ordered type from an
  * `Order.Order` instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function makeIsBetween<T>(deriveOptions: {
@@ -5784,7 +5783,7 @@ export declare function makeIsBetween<T>(deriveOptions: {
  * Creates a divisibility check for any numeric type from a remainder function
  * and a zero value.
  *
- * @category Numeric checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function makeIsMultipleOf<T>(options: {
@@ -5808,7 +5807,7 @@ export declare function makeIsMultipleOf<T>(options: {
  * `exclusiveMinimum` constraint to ensure generated numbers are greater than
  * the specified value.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThan: (exclusiveMinimum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
@@ -5821,7 +5820,7 @@ export declare const isGreaterThan: (exclusiveMinimum: number, annotations?: Ann
  *
  * @see {@link isGreaterThan} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanReviver: SchemaRepresentation.FilterReviver<{
@@ -5842,7 +5841,7 @@ export declare const isGreaterThanReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies a `minimum` constraint
  * to ensure generated numbers are greater than or equal to the specified value.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualTo: (minimum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
@@ -5855,7 +5854,7 @@ export declare const isGreaterThanOrEqualTo: (minimum: number, annotations?: Ann
  *
  * @see {@link isGreaterThanOrEqualTo} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualToReviver: SchemaRepresentation.FilterReviver<{
@@ -5876,7 +5875,7 @@ export declare const isGreaterThanOrEqualToReviver: SchemaRepresentation.FilterR
  * `exclusiveMaximum` constraint to ensure generated numbers are less than the
  * specified value.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThan: (exclusiveMaximum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
@@ -5889,7 +5888,7 @@ export declare const isLessThan: (exclusiveMaximum: number, annotations?: Annota
  *
  * @see {@link isLessThan} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanReviver: SchemaRepresentation.FilterReviver<{
@@ -5910,7 +5909,7 @@ export declare const isLessThanReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies a `maximum` constraint
  * to ensure generated numbers are less than or equal to the specified value.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanOrEqualTo: (maximum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
@@ -5923,7 +5922,7 @@ export declare const isLessThanOrEqualTo: (maximum: number, annotations?: Annota
  *
  * @see {@link isLessThanOrEqualTo} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanOrEqualToReviver: SchemaRepresentation.FilterReviver<{
@@ -5947,7 +5946,7 @@ export declare const isLessThanOrEqualToReviver: SchemaRepresentation.FilterRevi
  * `exclusiveMaximum` flags to ensure generated numbers fall within the
  * specified range.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBetween: (options: {
@@ -5965,7 +5964,7 @@ export declare const isBetween: (options: {
  *
  * @see {@link isBetween} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBetweenReviver: SchemaRepresentation.FilterReviver<{
@@ -5988,7 +5987,7 @@ export declare const isBetweenReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies constraints to ensure
  * generated numbers are multiples of the specified divisor.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isMultipleOf: (divisor: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
@@ -6001,7 +6000,7 @@ export declare const isMultipleOf: (divisor: number, annotations?: Annotations.F
  *
  * @see {@link isMultipleOf} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isMultipleOfReviver: SchemaRepresentation.FilterReviver<{
@@ -6022,7 +6021,7 @@ export declare const isMultipleOfReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies an `integer: true`
  * constraint to ensure generated numbers are integers.
  *
- * @category Integer checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isInt(annotations?: Annotations.Filter): SchemaAST.Filter<number>;
@@ -6035,14 +6034,14 @@ export declare function isInt(annotations?: Annotations.Filter): SchemaAST.Filte
  *
  * @see {@link isInt} for creating the corresponding check
  *
- * @category Integer checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isIntReviver: SchemaRepresentation.FilterReviver<null>;
 /**
  * Type-level representation of {@link Int}.
  *
- * @category Number
+ * @category models
  * @since 3.10.0
  */
 export interface Int extends Number {
@@ -6051,14 +6050,14 @@ export interface Int extends Number {
 /**
  * Schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.
  *
- * @category Number
+ * @category schemas
  * @since 3.10.0
  */
 export declare const Int: Int;
 /**
  * Type-level representation of {@link Natural}.
  *
- * @category Number
+ * @category models
  * @since 4.0.0
  */
 export interface Natural extends Int {
@@ -6073,7 +6072,7 @@ export interface Natural extends Int {
  *
  * @see {@link Int} for safe integers that may be negative
  *
- * @category Number
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Natural: Natural;
@@ -6093,7 +6092,7 @@ export declare const Natural: Natural;
  * When generating test data with fast-check, this applies integer and range
  * constraints to ensure generated numbers are 32-bit signed integers.
  *
- * @category Integer checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isInt32(annotations?: Annotations.Filter): SchemaAST.FilterGroup<number>;
@@ -6113,7 +6112,7 @@ export declare function isInt32(annotations?: Annotations.Filter): SchemaAST.Fil
  * When generating test data with fast-check, this applies integer and range
  * constraints to ensure generated numbers are 32-bit unsigned integers.
  *
- * @category Integer checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isUint32(annotations?: Annotations.Filter): SchemaAST.FilterGroup<number>;
@@ -6128,7 +6127,7 @@ export declare function isUint32(annotations?: Annotations.Filter): SchemaAST.Fi
  * one millisecond after the specified value to ensure generated Date objects are
  * greater than it.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanDate: (exclusiveMinimum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
@@ -6149,7 +6148,7 @@ export declare const isGreaterThanDate: (exclusiveMinimum: globalThis.Date, anno
  * to ensure generated Date objects are greater than or equal to the specified
  * date.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualToDate: (minimum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
@@ -6164,7 +6163,7 @@ export declare const isGreaterThanOrEqualToDate: (minimum: globalThis.Date, anno
  * one millisecond before the specified value to ensure generated Date objects
  * are less than it.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanDate: (exclusiveMaximum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
@@ -6185,7 +6184,7 @@ export declare const isLessThanDate: (exclusiveMaximum: globalThis.Date, annotat
  * to ensure generated Date objects are less than or equal to the specified
  * date.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanOrEqualToDate: (maximum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
@@ -6206,7 +6205,7 @@ export declare const isLessThanOrEqualToDate: (maximum: globalThis.Date, annotat
  * constraints to ensure generated Date objects fall within the specified range,
  * shifting exclusive bounds by one millisecond.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBetweenDate: (options: {
@@ -6226,7 +6225,7 @@ export declare const isBetweenDate: (options: {
  * `exclusiveMinimum + 1n` to ensure generated BigInts are greater than the
  * specified value.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanBigInt: (exclusiveMinimum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
@@ -6242,7 +6241,7 @@ export declare const isGreaterThanBigInt: (exclusiveMinimum: bigint, annotations
  * to ensure generated BigInt values are greater than or equal to the specified
  * value.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualToBigInt: (minimum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
@@ -6257,7 +6256,7 @@ export declare const isGreaterThanOrEqualToBigInt: (minimum: bigint, annotations
  * `exclusiveMaximum - 1n` to ensure generated BigInts are less than the
  * specified value.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanBigInt: (exclusiveMaximum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
@@ -6273,7 +6272,7 @@ export declare const isLessThanBigInt: (exclusiveMaximum: bigint, annotations?:
  * to ensure generated BigInt values are less than or equal to the specified
  * value.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanOrEqualToBigInt: (maximum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
@@ -6289,7 +6288,7 @@ export declare const isLessThanOrEqualToBigInt: (maximum: bigint, annotations?:
  * constraints to ensure generated BigInt values fall within the specified
  * range.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBetweenBigInt: (options: {
@@ -6301,7 +6300,7 @@ export declare const isBetweenBigInt: (options: {
 /**
  * Validates that a BigDecimal is greater than the specified value (exclusive).
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanBigDecimal: (exclusiveMinimum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
@@ -6309,14 +6308,14 @@ export declare const isGreaterThanBigDecimal: (exclusiveMinimum: BigDecimal_.Big
  * Validates that a BigDecimal is greater than or equal to the specified value
  * (inclusive).
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualToBigDecimal: (minimum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
 /**
  * Validates that a BigDecimal is less than the specified value (exclusive).
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanBigDecimal: (exclusiveMaximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
@@ -6324,7 +6323,7 @@ export declare const isLessThanBigDecimal: (exclusiveMaximum: BigDecimal_.BigDec
  * Validates that a BigDecimal is less than or equal to the specified value
  * (inclusive).
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanOrEqualToBigDecimal: (maximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
@@ -6336,7 +6335,7 @@ export declare const isLessThanOrEqualToBigDecimal: (maximum: BigDecimal_.BigDec
  * The minimum and maximum boundaries are inclusive by default. Pass
  * `exclusiveMinimum` or `exclusiveMaximum` to exclude either boundary.
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBetweenBigDecimal: (options: {
@@ -6364,14 +6363,16 @@ export declare const isBetweenBigDecimal: (options: {
  *
  * **Example** (Checking minimum length)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const NonEmptyStringSchema = Schema.String.check(Schema.isMinLength(1))
  * const NonEmptyArraySchema = Schema.Array(Schema.Number).check(Schema.isMinLength(1))
+ * Schema.is(NonEmptyStringSchema)("a") // => true
+ * Schema.is(NonEmptyArraySchema)([1]) // => true
  * ```
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isMinLength(minLength: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
@@ -6386,7 +6387,7 @@ export declare function isMinLength(minLength: number, annotations?: Annotations
  *
  * @see {@link isMinLength} for creating the corresponding check
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isMinLengthReviver: SchemaRepresentation.FilterReviver<{
@@ -6408,7 +6409,7 @@ export declare const isMinLengthReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies a `minLength: 1`
  * constraint to ensure generated strings or arrays are non-empty.
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isNonEmpty(annotations?: Annotations.Filter): SchemaAST.Filter<{
@@ -6431,7 +6432,7 @@ export declare function isNonEmpty(annotations?: Annotations.Filter): SchemaAST.
  * constraint to ensure generated strings or arrays have at most the required
  * length.
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isMaxLength(maxLength: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
@@ -6446,7 +6447,7 @@ export declare function isMaxLength(maxLength: number, annotations?: Annotations
  *
  * @see {@link isMaxLength} for creating the corresponding check
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isMaxLengthReviver: SchemaRepresentation.FilterReviver<{
@@ -6469,7 +6470,7 @@ export declare const isMaxLengthReviver: SchemaRepresentation.FilterReviver<{
  * `maxLength` constraints to ensure generated strings or arrays have a length
  * within the specified range.
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
@@ -6484,7 +6485,7 @@ export declare function isLengthBetween(minimum: number, maximum: number, annota
  *
  * @see {@link isLengthBetween} for creating the corresponding check
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLengthBetweenReviver: SchemaRepresentation.FilterReviver<{
@@ -6508,7 +6509,7 @@ export declare const isLengthBetweenReviver: SchemaRepresentation.FilterReviver<
  * `minLength` constraint. Generators for values with a final `.size`, such as
  * sets and maps, interpret it as final cardinality.
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isMinSize(minSize: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
@@ -6523,7 +6524,7 @@ export declare function isMinSize(minSize: number, annotations?: Annotations.Fil
  *
  * @see {@link isMinSize} for creating the corresponding check
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isMinSizeReviver: SchemaRepresentation.FilterReviver<{
@@ -6546,7 +6547,7 @@ export declare const isMinSizeReviver: SchemaRepresentation.FilterReviver<{
  * `maxLength` constraint. Generators for values with a final `.size`, such as
  * sets and maps, interpret it as final cardinality.
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isMaxSize(maxSize: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
@@ -6561,7 +6562,7 @@ export declare function isMaxSize(maxSize: number, annotations?: Annotations.Fil
  *
  * @see {@link isMaxSize} for creating the corresponding check
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isMaxSizeReviver: SchemaRepresentation.FilterReviver<{
@@ -6584,7 +6585,7 @@ export declare const isMaxSizeReviver: SchemaRepresentation.FilterReviver<{
  * `minLength` and `maxLength` constraints. Generators for values with a final
  * `.size`, such as sets and maps, interpret them as final cardinality.
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isSizeBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
@@ -6599,7 +6600,7 @@ export declare function isSizeBetween(minimum: number, maximum: number, annotati
  *
  * @see {@link isSizeBetween} for creating the corresponding check
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isSizeBetweenReviver: SchemaRepresentation.FilterReviver<{
@@ -6623,7 +6624,7 @@ export declare const isSizeBetweenReviver: SchemaRepresentation.FilterReviver<{
  * `minLength` constraint. Object generators interpret it as the final number
  * of own properties.
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isMinProperties(minProperties: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
@@ -6636,7 +6637,7 @@ export declare function isMinProperties(minProperties: number, annotations?: Ann
  *
  * @see {@link isMinProperties} for creating the corresponding check
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isMinPropertiesReviver: SchemaRepresentation.FilterReviver<{
@@ -6658,7 +6659,7 @@ export declare const isMinPropertiesReviver: SchemaRepresentation.FilterReviver<
  * `maxLength` constraint. Object generators interpret it as the final number
  * of own properties.
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isMaxProperties(maxProperties: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
@@ -6671,7 +6672,7 @@ export declare function isMaxProperties(maxProperties: number, annotations?: Ann
  *
  * @see {@link isMaxProperties} for creating the corresponding check
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isMaxPropertiesReviver: SchemaRepresentation.FilterReviver<{
@@ -6694,7 +6695,7 @@ export declare const isMaxPropertiesReviver: SchemaRepresentation.FilterReviver<
  * `minLength` and `maxLength` constraints. Object generators interpret them as
  * the final number of own properties.
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isPropertiesLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
@@ -6707,7 +6708,7 @@ export declare function isPropertiesLengthBetween(minimum: number, maximum: numb
  *
  * @see {@link isPropertiesLengthBetween} for creating the corresponding check
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isPropertiesLengthBetweenReviver: SchemaRepresentation.FilterReviver<{
@@ -6727,7 +6728,7 @@ export declare const isPropertiesLengthBetweenReviver: SchemaRepresentation.Filt
  * For string property names, this corresponds to the `propertyNames` constraint
  * in JSON Schema.
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isPropertyNames(keySchema: Constraint, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
@@ -6740,7 +6741,7 @@ export declare function isPropertyNames(keySchema: Constraint, annotations?: Ann
  *
  * @see {@link isPropertyNames} for creating the corresponding check
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isPropertyNamesReviver: SchemaRepresentation.FilterReviver<null>;
@@ -6757,7 +6758,7 @@ export declare const isPropertyNamesReviver: SchemaRepresentation.FilterReviver<
  * `unique: true` constraint. Array generators translate it to `fast-check`
  * `uniqueArray` using Effect equality.
  *
- * @category Array checks
+ * @category validation
  * @since 4.0.0
  */
 export declare function isUnique<T>(annotations?: Annotations.Filter): SchemaAST.Filter<readonly T[]>;
@@ -6770,14 +6771,14 @@ export declare function isUnique<T>(annotations?: Annotations.Filter): SchemaAST
  *
  * @see {@link isUnique} for creating the corresponding check
  *
- * @category Array checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isUniqueReviver: SchemaRepresentation.FilterReviver<null>;
 /**
  * Type-level representation of {@link NonEmptyString}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface NonEmptyString extends String {
@@ -6787,14 +6788,14 @@ export interface NonEmptyString extends String {
  * Schema for non-empty strings. Validates that a string has at least one
  * character.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export declare const NonEmptyString: NonEmptyString;
 /**
  * Type-level representation of {@link Char}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface Char extends String {
@@ -6816,14 +6817,14 @@ export interface Char extends String {
  * @see {@link NonEmptyString} for strings with length greater than zero
  * @see {@link isLengthBetween} for the underlying length check
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export declare const Char: Char;
 /**
  * Type-level representation returned by {@link Option}.
  *
- * @category Option
+ * @category models
  * @since 3.10.0
  */
 export interface Option<A extends Constraint> extends declareConstructor<Option_.Option<A["Type"]>, Option_.Option<A["Encoded"]>, readonly [A], OptionIso<A>> {
@@ -6838,7 +6839,7 @@ export interface Option<A extends Constraint> extends declareConstructor<Option_
  * `None` is represented as `{ _tag: "None" }`, while `Some` is represented as
  * `{ _tag: "Some", value }` using the wrapped schema's `Iso` type.
  *
- * @category Option
+ * @category utility types
  * @since 4.0.0
  */
 export type OptionIso<A extends Constraint> = {
@@ -6850,7 +6851,7 @@ export type OptionIso<A extends Constraint> = {
 /**
  * Schema for `Option<A>` values.
  *
- * @category Option
+ * @category schemas
  * @since 3.10.0
  */
 export declare function Option<A extends Constraint>(value: A): Option<A>;
@@ -6863,14 +6864,14 @@ export declare function Option<A extends Constraint>(value: A): Option<A>;
  *
  * @see {@link Option} for creating the corresponding schema
  *
- * @category Option
+ * @category schemas
  * @since 4.0.0
  */
 export declare const OptionReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link OptionFromNullOr}.
  *
- * @category Option
+ * @category models
  * @since 3.10.0
  */
 export interface OptionFromNullOr<S extends Constraint> extends decodeTo<Option<toType<S>>, NullOr<S>> {
@@ -6884,14 +6885,14 @@ export interface OptionFromNullOr<S extends Constraint> extends decodeTo<Option<
  * Decoding maps `null` to `None` and all other values to `Some`. Encoding maps
  * `None` to `null` and maps `Some` to its value.
  *
- * @category Option
+ * @category schemas
  * @since 3.10.0
  */
 export declare function OptionFromNullOr<S extends Constraint>(schema: S): OptionFromNullOr<S>;
 /**
  * Type-level representation returned by {@link OptionFromUndefinedOr}.
  *
- * @category Option
+ * @category models
  * @since 3.10.0
  */
 export interface OptionFromUndefinedOr<S extends Constraint> extends decodeTo<Option<toType<S>>, UndefinedOr<S>> {
@@ -6906,14 +6907,14 @@ export interface OptionFromUndefinedOr<S extends Constraint> extends decodeTo<Op
  * Decoding maps `undefined` to `None` and all other values to `Some`. Encoding
  * maps `None` to `undefined` and maps `Some` to its value.
  *
- * @category Option
+ * @category schemas
  * @since 3.10.0
  */
 export declare function OptionFromUndefinedOr<S extends Constraint>(schema: S): OptionFromUndefinedOr<S>;
 /**
  * Type-level representation returned by {@link OptionFromNullishOr}.
  *
- * @category Option
+ * @category models
  * @since 3.10.0
  */
 export interface OptionFromNullishOr<S extends Constraint> extends decodeTo<Option<toType<S>>, NullishOr<S>> {
@@ -6929,7 +6930,7 @@ export interface OptionFromNullishOr<S extends Constraint> extends decodeTo<Opti
  * `options.onNoneEncoding`, which defaults to `undefined`, and maps `Some` to
  * its value.
  *
- * @category Option
+ * @category schemas
  * @since 3.10.0
  */
 export declare function OptionFromNullishOr<S extends Constraint>(schema: S, options?: {
@@ -6938,7 +6939,7 @@ export declare function OptionFromNullishOr<S extends Constraint>(schema: S, opt
 /**
  * Type-level representation returned by {@link OptionFromOptionalKey}.
  *
- * @category Option
+ * @category models
  * @since 4.0.0
  */
 export interface OptionFromOptionalKey<S extends Constraint> extends decodeTo<Option<toType<S>>, optionalKey<S>> {
@@ -6952,14 +6953,14 @@ export interface OptionFromOptionalKey<S extends Constraint> extends decodeTo<Op
  * Decoding maps a missing key to `None` and a present value to `Some`.
  * Encoding maps `None` to a missing key and maps `Some` to its value.
  *
- * @category Option
+ * @category schemas
  * @since 4.0.0
  */
 export declare function OptionFromOptionalKey<S extends Constraint>(schema: S): OptionFromOptionalKey<S>;
 /**
  * Type-level representation returned by {@link OptionFromOptional}.
  *
- * @category Option
+ * @category models
  * @since 4.0.0
  */
 export interface OptionFromOptional<S extends Constraint> extends decodeTo<Option<toType<S>>, optional<S>> {
@@ -6975,14 +6976,14 @@ export interface OptionFromOptional<S extends Constraint> extends decodeTo<Optio
  * maps all other values to `Some`. Encoding maps `None` to a missing key and
  * maps `Some` to its value.
  *
- * @category Option
+ * @category schemas
  * @since 4.0.0
  */
 export declare function OptionFromOptional<S extends Constraint>(schema: S): OptionFromOptional<S>;
 /**
  * Type-level representation returned by {@link OptionFromOptionalNullOr}.
  *
- * @category Option
+ * @category models
  * @since 4.0.0
  */
 export interface OptionFromOptionalNullOr<S extends Constraint> extends decodeTo<Option<toType<S>>, optional<NullOr<S>>> {
@@ -6999,7 +7000,7 @@ export interface OptionFromOptionalNullOr<S extends Constraint> extends decodeTo
  * according to `options.onNoneEncoding`: `"omit"` encodes a missing key,
  * `null` encodes `null`, and `undefined` encodes `undefined`.
  *
- * @category Option
+ * @category schemas
  * @since 4.0.0
  */
 export declare function OptionFromOptionalNullOr<S extends Constraint>(schema: S, options?: {
@@ -7008,7 +7009,7 @@ export declare function OptionFromOptionalNullOr<S extends Constraint>(schema: S
 /**
  * Type-level representation returned by {@link Result}.
  *
- * @category schemas
+ * @category models
  * @since 4.0.0
  */
 export interface Result<A extends Constraint, E extends Constraint> extends declareConstructor<Result_.Result<A["Type"], E["Type"]>, Result_.Result<A["Encoded"], E["Encoded"]>, readonly [A, E], ResultIso<A, E>> {
@@ -7024,7 +7025,7 @@ export interface Result<A extends Constraint, E extends Constraint> extends decl
  * Successful results are represented as `{ _tag: "Success", success }`, while
  * failed results are represented as `{ _tag: "Failure", failure }`.
  *
- * @category schemas
+ * @category utility types
  * @since 4.0.0
  */
 export type ResultIso<A extends Constraint, E extends Constraint> = {
@@ -7057,7 +7058,7 @@ export declare const ResultReviver: SchemaRepresentation.DeclarationReviver<null
 /**
  * Type-level representation returned by {@link Redacted}.
  *
- * @category Redacted
+ * @category models
  * @since 3.10.0
  */
 export interface Redacted<S extends Constraint> extends declareConstructor<Redacted_.Redacted<S["Type"]>, Redacted_.Redacted<S["Encoded"]>, readonly [S]> {
@@ -7071,13 +7072,7 @@ type RedactedRepresentationOptions = {
 type RedactedRepresentationPayload = RedactedRepresentationOptions | null;
 declare const RedactedRepresentationPayload: Decoder<RedactedRepresentationPayload>;
 /**
- * Schema for values that hide sensitive information from error output and
- * inspection.
- *
- * **Details**
- *
- * If the wrapped schema fails, the issue will be redacted to prevent both
- * the actual value and the schema details from being exposed.
+ * Schema for `Redacted` values, which hide their contents from inspection.
  *
  * Options:
  *
@@ -7091,7 +7086,7 @@ declare const RedactedRepresentationPayload: Decoder<RedactedRepresentationPaylo
  *   sensitive and should not be exposed in JSON.
  *
  * @see {@link RedactedFromValue} for decoding raw values and wrapping them in `Redacted`.
- * @category Redacted
+ * @category schemas
  * @since 3.10.0
  */
 export declare function Redacted<S extends Constraint>(value: S, options?: {
@@ -7107,34 +7102,26 @@ export declare function Redacted<S extends Constraint>(value: S, options?: {
  *
  * @see {@link Redacted} for creating the corresponding schema
  *
- * @category Redacted
+ * @category schemas
  * @since 4.0.0
  */
 export declare const RedactedReviver: SchemaRepresentation.DeclarationReviver<RedactedRepresentationPayload>;
 /**
  * Type-level representation returned by {@link RedactedFromValue}.
  *
- * @category Redacted
+ * @category models
  * @since 4.0.0
  */
-export interface RedactedFromValue<S extends Constraint> extends decodeTo<Redacted<toType<S>>, middlewareDecoding<S, S["DecodingServices"]>> {
+export interface RedactedFromValue<S extends Constraint> extends decodeTo<Redacted<toType<S>>, S> {
     readonly "Rebuild": RedactedFromValue<S>;
 }
-/**
- * Middleware that wraps decoded errors in `Redacted`, preventing sensitive
- * schema details from leaking in error messages.
- *
- * @category Redacted
- * @since 4.0.0
- */
-export declare function redact<S extends Constraint>(schema: S): middlewareDecoding<S, S["DecodingServices"]>;
 /**
  * Decodes a value and wraps it in `Redacted<A>`. Unlike {@link Redacted} which
  * expects the input to already be a `Redacted` instance, this schema decodes
  * the raw value and wraps it.
  *
  * @see {@link Redacted} for schemas whose input is already a `Redacted` value.
- * @category Redacted
+ * @category schemas
  * @since 4.0.0
  */
 export declare function RedactedFromValue<S extends Constraint>(value: S, options?: {
@@ -7144,7 +7131,7 @@ export declare function RedactedFromValue<S extends Constraint>(value: S, option
 /**
  * Type-level representation returned by {@link CauseReason}.
  *
- * @category CauseReason
+ * @category models
  * @since 4.0.0
  */
 export interface CauseReason<E extends Constraint, D extends Constraint> extends declareConstructor<Cause_.Reason<E["Type"]>, Cause_.Reason<E["Encoded"]>, readonly [E, D], CauseReasonIso<E, D>> {
@@ -7160,7 +7147,7 @@ export interface CauseReason<E extends Constraint, D extends Constraint> extends
  * Failures are represented with a `Fail` tag and encoded error, defects with a
  * `Die` tag and encoded defect, and interrupts with an optional `fiberId`.
  *
- * @category CauseReason
+ * @category utility types
  * @since 4.0.0
  */
 export type CauseReasonIso<E extends Constraint, D extends Constraint> = {
@@ -7190,7 +7177,7 @@ export type CauseReasonIso<E extends Constraint, D extends Constraint> = {
  * @see {@link Cause} for constructing schemas for full Cause values
  * @see {@link CauseReasonIso} for the ISO shape of each cause reason
  *
- * @category CauseReason
+ * @category schemas
  * @since 4.0.0
  */
 export declare function CauseReason<E extends Constraint, D extends Constraint>(error: E, defect: D): CauseReason<E, D>;
@@ -7203,14 +7190,14 @@ export declare function CauseReason<E extends Constraint, D extends Constraint>(
  *
  * @see {@link CauseReason} for creating the corresponding schema
  *
- * @category CauseReason
+ * @category schemas
  * @since 4.0.0
  */
 export declare const CauseReasonReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link Cause}.
  *
- * @category Cause
+ * @category models
  * @since 3.10.0
  */
 export interface Cause<E extends Constraint, D extends Constraint> extends declareConstructor<Cause_.Cause<E["Type"]>, Cause_.Cause<E["Encoded"]>, readonly [E, D], CauseIso<E, D>> {
@@ -7230,7 +7217,7 @@ export interface Cause<E extends Constraint, D extends Constraint> extends decla
  * @see {@link Cause} for constructing schemas for full Cause values
  * @see {@link CauseReasonIso} for the ISO shape of each array element
  *
- * @category Cause
+ * @category utility types
  * @since 4.0.0
  */
 export type CauseIso<E extends Constraint, D extends Constraint> = ReadonlyArray<CauseReasonIso<E, D>>;
@@ -7252,7 +7239,7 @@ export type CauseIso<E extends Constraint, D extends Constraint> = ReadonlyArray
  * @see {@link CauseReason} for the schema used by each individual cause reason
  * @see {@link CauseIso} for the ordered array representation used by the schema ISO
  *
- * @category Cause
+ * @category schemas
  * @since 3.10.0
  */
 export declare function Cause<E extends Constraint, D extends Constraint>(error: E, defect: D): Cause<E, D>;
@@ -7265,14 +7252,14 @@ export declare function Cause<E extends Constraint, D extends Constraint>(error:
  *
  * @see {@link Cause} for creating the corresponding schema
  *
- * @category Cause
+ * @category schemas
  * @since 4.0.0
  */
 export declare const CauseReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link Error}.
  *
- * @category Error
+ * @category models
  * @since 4.0.0
  */
 export interface Error extends instanceOf<globalThis.Error> {
@@ -7317,7 +7304,7 @@ declare const ErrorRepresentationPayload: Decoder<ErrorRepresentationPayload>;
  * traces are omitted by default for security. Pass `{ includeStack: true }` to
  * include stack traces, or `{ excludeCause: true }` to omit causes.
  *
- * @category constructors
+ * @category schemas
  * @since 4.0.0
  */
 export declare function Error(options?: ErrorOptions): Error;
@@ -7330,14 +7317,14 @@ export declare function Error(options?: ErrorOptions): Error;
  *
  * @see {@link Error} for creating the corresponding schema
  *
- * @category Error
+ * @category schemas
  * @since 4.0.0
  */
 export declare const ErrorReviver: SchemaRepresentation.DeclarationReviver<ErrorRepresentationPayload>;
 /**
  * Type-level representation of {@link Defect}.
  *
- * @category Defect
+ * @category models
  * @since 3.10.0
  */
 export interface Defect extends decodeTo<Unknown, typeof Json> {
@@ -7381,14 +7368,14 @@ export interface Defect extends decodeTo<Unknown, typeof Json> {
  *   string representation.
  *
  * @see {@link Error} for a schema that only accepts JavaScript `Error` values.
- * @category constructors
+ * @category schemas
  * @since 4.0.0
  */
 export declare function Defect(options?: ErrorOptions): Defect;
 /**
  * Type-level representation returned by {@link Exit}.
  *
- * @category Exit
+ * @category models
  * @since 3.10.0
  */
 export interface Exit<A extends Constraint, E extends Constraint, D extends Constraint> extends declareConstructor<Exit_.Exit<A["Type"], E["Type"]>, Exit_.Exit<A["Encoded"], E["Encoded"]>, readonly [A, E, D], ExitIso<A, E, D>> {
@@ -7405,7 +7392,7 @@ export interface Exit<A extends Constraint, E extends Constraint, D extends Cons
  * Successful exits are represented as `{ _tag: "Success", value }`, while failed
  * exits are represented as `{ _tag: "Failure", cause }`.
  *
- * @category Exit
+ * @category utility types
  * @since 4.0.0
  */
 export type ExitIso<A extends Constraint, E extends Constraint, D extends Constraint> = {
@@ -7424,7 +7411,7 @@ export type ExitIso<A extends Constraint, E extends Constraint, D extends Constr
  * Use when serializing or validating an effect outcome where success, typed
  * failure, and defects each need their own schema.
  *
- * @category Exit
+ * @category schemas
  * @since 3.10.0
  */
 export declare function Exit<A extends Constraint, E extends Constraint, D extends Constraint>(value: A, error: E, defect: D): Exit<A, E, D>;
@@ -7437,14 +7424,14 @@ export declare function Exit<A extends Constraint, E extends Constraint, D exten
  *
  * @see {@link Exit} for creating the corresponding schema
  *
- * @category Exit
+ * @category schemas
  * @since 4.0.0
  */
 export declare const ExitReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link ReadonlyMap}.
  *
- * @category ReadonlyMap
+ * @category models
  * @since 4.0.0
  */
 export interface $ReadonlyMap<Key extends Constraint, Value extends Constraint> extends declareConstructor<globalThis.ReadonlyMap<Key["Type"], Value["Type"]>, globalThis.ReadonlyMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], ReadonlyMapIso<Key, Value>> {
@@ -7456,7 +7443,7 @@ export interface $ReadonlyMap<Key extends Constraint, Value extends Constraint>
  * Iso representation used for `ReadonlyMap` schemas: an array of readonly
  * `[key, value]` tuples using each entry schema's `Iso` type.
  *
- * @category ReadonlyMap
+ * @category utility types
  * @since 4.0.0
  */
 export type ReadonlyMapIso<Key extends Constraint, Value extends Constraint> = ReadonlyArray<readonly [Key["Iso"], Value["Iso"]]>;
@@ -7464,7 +7451,7 @@ export type ReadonlyMapIso<Key extends Constraint, Value extends Constraint> = R
  * Schema for readonly maps whose keys and values conform to the provided
  * schemas.
  *
- * @category ReadonlyMap
+ * @category schemas
  * @since 3.10.0
  */
 export declare function ReadonlyMap<Key extends Constraint, Value extends Constraint>(key: Key, value: Value): $ReadonlyMap<Key, Value>;
@@ -7477,14 +7464,14 @@ export declare function ReadonlyMap<Key extends Constraint, Value extends Constr
  *
  * @see {@link ReadonlyMap} for creating the corresponding schema
  *
- * @category ReadonlyMap
+ * @category schemas
  * @since 4.0.0
  */
 export declare const ReadonlyMapReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link HashMap}.
  *
- * @category HashMap
+ * @category models
  * @since 3.10.0
  */
 export interface HashMap<Key extends Constraint, Value extends Constraint> extends declareConstructor<HashMap_.HashMap<Key["Type"], Value["Type"]>, HashMap_.HashMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], HashMapIso<Key, Value>> {
@@ -7496,14 +7483,14 @@ export interface HashMap<Key extends Constraint, Value extends Constraint> exten
  * Iso representation used for `HashMap` schemas: an array of readonly
  * `[key, value]` tuples using each entry schema's `Iso` type.
  *
- * @category HashMap
+ * @category utility types
  * @since 4.0.0
  */
 export type HashMapIso<Key extends Constraint, Value extends Constraint> = ReadonlyArray<readonly [Key["Iso"], Value["Iso"]]>;
 /**
  * Schema for hash maps whose keys and values conform to the provided schemas.
  *
- * @category HashMap
+ * @category schemas
  * @since 3.10.0
  */
 export declare function HashMap<Key extends Constraint, Value extends Constraint>(key: Key, value: Value): HashMap<Key, Value>;
@@ -7516,14 +7503,14 @@ export declare function HashMap<Key extends Constraint, Value extends Constraint
  *
  * @see {@link HashMap} for creating the corresponding schema
  *
- * @category HashMap
+ * @category schemas
  * @since 4.0.0
  */
 export declare const HashMapReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link ReadonlySet}.
  *
- * @category ReadonlySet
+ * @category models
  * @since 4.0.0
  */
 export interface $ReadonlySet<Value extends Constraint> extends declareConstructor<globalThis.ReadonlySet<Value["Type"]>, globalThis.ReadonlySet<Value["Encoded"]>, readonly [Value], ReadonlySetIso<Value>> {
@@ -7534,14 +7521,14 @@ export interface $ReadonlySet<Value extends Constraint> extends declareConstruct
  * Iso representation used for `ReadonlySet` schemas: an array of element values
  * using the element schema's `Iso` type.
  *
- * @category ReadonlySet
+ * @category utility types
  * @since 4.0.0
  */
 export type ReadonlySetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
 /**
  * Schema for readonly sets whose values conform to the provided element schema.
  *
- * @category ReadonlySet
+ * @category schemas
  * @since 3.10.0
  */
 export declare function ReadonlySet<Value extends Constraint>(value: Value): $ReadonlySet<Value>;
@@ -7554,14 +7541,14 @@ export declare function ReadonlySet<Value extends Constraint>(value: Value): $Re
  *
  * @see {@link ReadonlySet} for creating the corresponding schema
  *
- * @category ReadonlySet
+ * @category schemas
  * @since 4.0.0
  */
 export declare const ReadonlySetReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link HashSet}.
  *
- * @category HashSet
+ * @category models
  * @since 3.10.0
  */
 export interface HashSet<Value extends Constraint> extends declareConstructor<HashSet_.HashSet<Value["Type"]>, HashSet_.HashSet<Value["Encoded"]>, readonly [Value], HashSetIso<Value>> {
@@ -7572,14 +7559,14 @@ export interface HashSet<Value extends Constraint> extends declareConstructor<Ha
  * Iso representation used for `HashSet` schemas: an array of element values
  * using the element schema's `Iso` type.
  *
- * @category HashSet
+ * @category utility types
  * @since 4.0.0
  */
 export type HashSetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
 /**
  * Schema for hash sets whose values conform to the provided element schema.
  *
- * @category HashSet
+ * @category schemas
  * @since 3.10.0
  */
 export declare function HashSet<Value extends Constraint>(value: Value): HashSet<Value>;
@@ -7592,14 +7579,14 @@ export declare function HashSet<Value extends Constraint>(value: Value): HashSet
  *
  * @see {@link HashSet} for creating the corresponding schema
  *
- * @category HashSet
+ * @category schemas
  * @since 4.0.0
  */
 export declare const HashSetReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link Chunk}.
  *
- * @category Chunk
+ * @category models
  * @since 3.10.0
  */
 export interface Chunk<Value extends Constraint> extends declareConstructor<Chunk_.Chunk<Value["Type"]>, Chunk_.Chunk<Value["Encoded"]>, readonly [Value], ChunkIso<Value>> {
@@ -7617,14 +7604,14 @@ export interface Chunk<Value extends Constraint> extends declareConstructor<Chun
  *
  * @see {@link Chunk} for the schema interface and constructor that use this ISO representation
  *
- * @category Chunk
+ * @category utility types
  * @since 4.0.0
  */
 export type ChunkIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
 /**
  * Schema for chunks whose values conform to the provided element schema.
  *
- * @category Chunk
+ * @category schemas
  * @since 3.10.0
  */
 export declare function Chunk<Value extends Constraint>(value: Value): Chunk<Value>;
@@ -7637,14 +7624,14 @@ export declare function Chunk<Value extends Constraint>(value: Value): Chunk<Val
  *
  * @see {@link Chunk} for creating the corresponding schema
  *
- * @category Chunk
+ * @category schemas
  * @since 4.0.0
  */
 export declare const ChunkReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link RegExp}.
  *
- * @category RegExp
+ * @category models
  * @since 4.0.0
  */
 export interface RegExp extends instanceOf<globalThis.RegExp> {
@@ -7657,7 +7644,7 @@ export interface RegExp extends instanceOf<globalThis.RegExp> {
  *
  * The default JSON serializer encodes a `RegExp` as `{ source, flags }`.
  *
- * @category RegExp
+ * @category schemas
  * @since 4.0.0
  */
 export declare const RegExp: RegExp;
@@ -7670,14 +7657,14 @@ export declare const RegExp: RegExp;
  *
  * @see {@link RegExp} for the corresponding schema
  *
- * @category RegExp
+ * @category schemas
  * @since 4.0.0
  */
 export declare const RegExpReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link URL}.
  *
- * @category URL
+ * @category models
  * @since 4.0.0
  */
 export interface URL extends instanceOf<globalThis.URL> {
@@ -7692,7 +7679,7 @@ export interface URL extends instanceOf<globalThis.URL> {
  *
  * - encodes `URL` as a `string`
  *
- * @category URL
+ * @category schemas
  * @since 4.0.0
  */
 export declare const URL: URL;
@@ -7705,14 +7692,14 @@ export declare const URL: URL;
  *
  * @see {@link URL} for the corresponding schema
  *
- * @category URL
+ * @category schemas
  * @since 4.0.0
  */
 export declare const URLReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link URLFromString}.
  *
- * @category URL
+ * @category models
  * @since 4.0.0
  */
 export interface URLFromString extends decodeTo<URL, String> {
@@ -7729,14 +7716,14 @@ export interface URLFromString extends decodeTo<URL, String> {
  * Encoding:
  * - A `URL` is encoded as a `string`
  *
- * @category URL
+ * @category schemas
  * @since 4.0.0
  */
 export declare const URLFromString: URLFromString;
 /**
  * Type-level representation of {@link Date}.
  *
- * @category Date
+ * @category models
  * @since 4.0.0
  */
 export interface Date extends declare<globalThis.Date> {
@@ -7757,17 +7744,17 @@ export interface Date extends declare<globalThis.Date> {
  *
  * **Example** (Defining a Date schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
- * Schema.decodeUnknownSync(Schema.Date)(new Date("2024-01-01"))
- * // => Date { 2024-01-01T00:00:00.000Z }
+ * const date = Schema.decodeUnknownSync(Schema.Date)(new Date("2024-01-01"))
+ * date.toISOString() // => "2024-01-01T00:00:00.000Z"
  * ```
  *
  * @see {@link DateFromString} for decoding strings into Date instances
  * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
  *
- * @category Date
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Date: Date;
@@ -7780,14 +7767,14 @@ export declare const Date: Date;
  *
  * @see {@link Date} for the corresponding schema
  *
- * @category Date
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DateReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link DateFromString}.
  *
- * @category Date
+ * @category models
  * @since 3.10.0
  */
 export interface DateFromString extends decodeTo<Date, String> {
@@ -7815,14 +7802,14 @@ export interface DateFromString extends decodeTo<Date, String> {
  * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
  * @see {@link Date} for accepting Date instances directly
  *
- * @category Date
+ * @category schemas
  * @since 3.10.0
  */
 export declare const DateFromString: DateFromString;
 /**
  * Type-level representation of {@link DateFromMillis}.
  *
- * @category Date
+ * @category models
  * @since 4.0.0
  */
 export interface DateFromMillis extends decodeTo<Date, Int> {
@@ -7853,14 +7840,14 @@ export interface DateFromMillis extends decodeTo<Date, Int> {
  * @see {@link DateFromString} for decoding string-encoded dates
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
  *
- * @category Date
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DateFromMillis: DateFromMillis;
 /**
  * Type-level representation of {@link Duration}.
  *
- * @category Duration
+ * @category models
  * @since 3.10.0
  */
 export interface Duration extends declare<Duration_.Duration> {
@@ -7876,14 +7863,13 @@ export interface Duration extends declare<Duration_.Duration> {
  *
  * **Example** (Defining a Duration schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Duration, Schema } from "effect"
  *
- * Schema.decodeUnknownSync(Schema.Duration)(Duration.seconds(5))
- * // => Duration(5s)
+ * Schema.decodeUnknownSync(Schema.Duration)(Duration.seconds(5)) // => Duration.seconds(5)
  * ```
  *
- * @category Duration
+ * @category schemas
  *
  * @since 3.10.0
  */
@@ -7897,14 +7883,14 @@ export declare const Duration: Duration;
  *
  * @see {@link Duration} for the corresponding schema
  *
- * @category Duration
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DurationReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link DurationFromString}.
  *
- * @category Duration
+ * @category models
  * @since 4.0.0
  */
 export interface DurationFromString extends decodeTo<Duration, String> {
@@ -7922,14 +7908,14 @@ export interface DurationFromString extends decodeTo<Duration, String> {
  * Encoding:
  * - A `Duration` is encoded as a parseable `string`.
  *
- * @category Duration
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DurationFromString: DurationFromString;
 /**
  * Type-level representation of {@link DurationFromNanos}.
  *
- * @category Duration
+ * @category models
  * @since 3.10.0
  */
 export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
@@ -7949,14 +7935,14 @@ export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
  * fails when the duration cannot be represented as nanoseconds, such as
  * `Duration.infinity` or `Duration.negativeInfinity`.
  *
- * @category Duration
+ * @category schemas
  * @since 3.10.0
  */
 export declare const DurationFromNanos: DurationFromNanos;
 /**
  * Type-level representation of {@link DurationFromMillis}.
  *
- * @category Duration
+ * @category models
  * @since 3.10.0
  */
 export interface DurationFromMillis extends decodeTo<Duration, Number> {
@@ -7978,14 +7964,14 @@ export interface DurationFromMillis extends decodeTo<Duration, Number> {
  *
  * `NaN` is decoded as `Duration.zero`, matching `Duration.millis`.
  *
- * @category Duration
+ * @category schemas
  * @since 3.10.0
  */
 export declare const DurationFromMillis: DurationFromMillis;
 /**
  * Type-level representation of {@link BigDecimal}.
  *
- * @category BigDecimal
+ * @category models
  * @since 3.10.0
  */
 export interface BigDecimal extends declare<BigDecimal_.BigDecimal> {
@@ -8007,7 +7993,7 @@ export interface BigDecimal extends declare<BigDecimal_.BigDecimal> {
  *
  * @see {@link BigDecimalFromString} for parsing string input into a BigDecimal
  *
- * @category BigDecimal
+ * @category schemas
  * @since 3.10.0
  */
 export declare const BigDecimal: BigDecimal;
@@ -8020,14 +8006,14 @@ export declare const BigDecimal: BigDecimal;
  *
  * @see {@link BigDecimal} for the corresponding schema
  *
- * @category BigDecimal
+ * @category schemas
  * @since 4.0.0
  */
 export declare const BigDecimalReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link BigDecimalFromString}.
  *
- * @category BigDecimal
+ * @category models
  * @since 4.0.0
  */
 export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
@@ -8057,45 +8043,10 @@ export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
  * @see {@link BigIntFromString} for parsing base-10 integer strings into bigint values
  * @see {@link NumberFromString} for parsing JavaScript number strings
  *
- * @category BigDecimal
- * @since 4.0.0
- */
-export declare const BigDecimalFromString: BigDecimalFromString;
-/**
- * Type-level representation of {@link UnknownFromJsonString}.
- *
- * @category models
- * @since 4.0.0
- */
-export interface UnknownFromJsonString extends fromJsonString<Unknown> {
-    readonly "Rebuild": UnknownFromJsonString;
-}
-/**
- * Schema that decodes a JSON-encoded string into an `unknown` value.
- *
- * **Details**
- *
- * Decoding:
- * - A `string` is decoded as an `unknown` value.
- * - If the string is not valid JSON, decoding fails.
- *
- * Encoding:
- * - Any value is encoded as a JSON string using `JSON.stringify`.
- * - If the value is not a valid JSON value, encoding fails.
- *
- * **Example** (Decoding unknown JSON strings)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * Schema.decodeUnknownSync(Schema.UnknownFromJsonString)(`{"a":1,"b":2}`)
- * // => { a: 1, b: 2 }
- * ```
- *
  * @category schemas
  * @since 4.0.0
  */
-export declare const UnknownFromJsonString: UnknownFromJsonString;
+export declare const BigDecimalFromString: BigDecimalFromString;
 /**
  * Type-level representation returned by {@link fromJsonString}.
  *
@@ -8114,29 +8065,35 @@ export interface fromJsonString<S extends Constraint> extends decodeTo<S, String
  * This is useful when working with JSON-encoded strings where the actual
  * structure of the value is known and described by an existing schema.
  *
- * The resulting schema first parses the input string as JSON, and then runs the
- * provided schema on the parsed result.
+ * During decoding, the resulting schema first parses the input string as JSON,
+ * using `reviver` when provided, and then runs the provided schema on the
+ * parsed result. During encoding, it first encodes with the provided schema and
+ * then passes the result to `JSON.stringify` with the optional `replacer` and
+ * `space`.
  *
- * **Example** (Decoding JSON strings with a schema)
+ * **Example** (Formatting encoded JSON)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Struct({ a: Schema.Number })
- * const schemaFromJsonString = Schema.fromJsonString(schema)
+ * const schemaFromJsonString = Schema.fromJsonString(schema, { space: 2 })
  *
- * Schema.decodeUnknownSync(schemaFromJsonString)(`{"a":1,"b":2}`)
- * // => { a: 1 }
+ * Schema.encodeSync(schemaFromJsonString)({ a: 1 }) // => "{\n  \"a\": 1\n}"
  * ```
  *
- * @category constructors
+ * @category schemas
  * @since 4.0.0
  */
-export declare function fromJsonString<S extends Constraint>(schema: S): fromJsonString<S>;
+export declare function fromJsonString<S extends Constraint>(schema: S, options?: {
+    readonly reviver?: Parameters<typeof JSON.parse>[1] | undefined;
+    readonly replacer?: SchemaGetter.JsonReplacer | undefined;
+    readonly space?: Parameters<typeof JSON.stringify>[2] | undefined;
+}): fromJsonString<S>;
 /**
  * Type-level representation of {@link File}.
  *
- * @category file
+ * @category models
  * @since 4.0.0
  */
 export interface File extends instanceOf<globalThis.File> {
@@ -8150,7 +8107,7 @@ export interface File extends instanceOf<globalThis.File> {
  * The default JSON serializer encodes a `File` as `{ data, type, name, lastModified }`
  * where `data` is base64-encoded.
  *
- * @category file
+ * @category schemas
  * @since 4.0.0
  */
 export declare const File: File;
@@ -8163,14 +8120,14 @@ export declare const File: File;
  *
  * @see {@link File} for the corresponding schema
  *
- * @category file
+ * @category schemas
  * @since 4.0.0
  */
 export declare const FileReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link FormData}.
  *
- * @category FormData
+ * @category models
  * @since 4.0.0
  */
 export interface FormData extends instanceOf<globalThis.FormData> {
@@ -8184,7 +8141,7 @@ export interface FormData extends instanceOf<globalThis.FormData> {
  * The default JSON serializer encodes a `FormData` as an array of `[key, entry]`
  * pairs where each entry is tagged as `"String"` or `"File"`.
  *
- * @category FormData
+ * @category schemas
  * @since 4.0.0
  */
 export declare const FormData: FormData;
@@ -8197,14 +8154,14 @@ export declare const FormData: FormData;
  *
  * @see {@link FormData} for the corresponding schema
  *
- * @category FormData
+ * @category schemas
  * @since 4.0.0
  */
 export declare const FormDataReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link fromFormData}.
  *
- * @category FormData
+ * @category models
  * @since 4.0.0
  */
 export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData> {
@@ -8231,7 +8188,7 @@ export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData
  *
  * **Example** (Decoding a flat structure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromFormData(
@@ -8244,13 +8201,12 @@ export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData
  * formData.append("a", "1")
  * formData.append("b", "2")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(formData)))
- * // Success({"a":"1"})
+ * Schema.decodeUnknownSync(schema)(formData) // => { a: "1" }
  * ```
  *
  * **Example** (Decoding nested fields)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromFormData(
@@ -8268,13 +8224,12 @@ export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData
  * formData.append("b[c]", "2")
  * formData.append("b[d]", "3")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(formData)))
- * // Success({"a":"1","b":{"c":"2","d":"3"}})
+ * Schema.decodeUnknownSync(schema)(formData) // => { a: "1", b: { c: "2", d: "3" } }
  * ```
  *
  * **Example** (Parsing non-string values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromFormData(
@@ -8288,8 +8243,7 @@ export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData
  * const formData = new FormData()
  * formData.append("a", "1")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(formData)))
- * // Success({"a":1}) // Note: the value is a number
+ * Schema.decodeUnknownSync(schema)(formData) // => { a: 1 }
  * ```
  *
  * @category decoding
@@ -8299,7 +8253,7 @@ export declare function fromFormData<S extends Constraint>(schema: S): fromFormD
 /**
  * Type-level representation of {@link URLSearchParams}.
  *
- * @category search params
+ * @category models
  * @since 4.0.0
  */
 export interface URLSearchParams extends instanceOf<globalThis.URLSearchParams> {
@@ -8312,7 +8266,7 @@ export interface URLSearchParams extends instanceOf<globalThis.URLSearchParams>
  *
  * The default JSON serializer encodes a `URLSearchParams` as a query string.
  *
- * @category search params
+ * @category schemas
  * @since 4.0.0
  */
 export declare const URLSearchParams: URLSearchParams;
@@ -8325,14 +8279,14 @@ export declare const URLSearchParams: URLSearchParams;
  *
  * @see {@link URLSearchParams} for the corresponding schema
  *
- * @category search params
+ * @category schemas
  * @since 4.0.0
  */
 export declare const URLSearchParamsReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation returned by {@link fromURLSearchParams}.
  *
- * @category search params
+ * @category models
  * @since 4.0.0
  */
 export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, URLSearchParams> {
@@ -8360,7 +8314,7 @@ export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, U
  *
  * **Example** (Decoding a flat structure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromURLSearchParams(
@@ -8371,13 +8325,12 @@ export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, U
  *
  * const urlSearchParams = new URLSearchParams("a=1&b=2")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(urlSearchParams)))
- * // Success({"a":"1"})
+ * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: "1" }
  * ```
  *
  * **Example** (Decoding nested fields)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromURLSearchParams(
@@ -8392,13 +8345,12 @@ export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, U
  *
  * const urlSearchParams = new URLSearchParams("a=1&b[c]=2&b[d]=3")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(urlSearchParams)))
- * // Success({"a":"1","b":{"c":"2","d":"3"}})
+ * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: "1", b: { c: "2", d: "3" } }
  * ```
  *
  * **Example** (Parsing non-string values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromURLSearchParams(
@@ -8411,8 +8363,7 @@ export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, U
  *
  * const urlSearchParams = new URLSearchParams("a=1&b=2")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(urlSearchParams)))
- * // Success({"a":1}) // Note: the value is a number
+ * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: 1 }
  * ```
  *
  * @category decoding
@@ -8422,7 +8373,7 @@ export declare function fromURLSearchParams<S extends Constraint>(schema: S): fr
 /**
  * Type-level representation of {@link NumberFromString}.
  *
- * @category Number
+ * @category models
  * @since 3.10.0
  */
 export interface NumberFromString extends decodeTo<Number, String> {
@@ -8442,14 +8393,14 @@ export interface NumberFromString extends decodeTo<Number, String> {
  * Encoding:
  * A number is encoded as a `string`.
  *
- * @category Number
+ * @category schemas
  * @since 3.10.0
  */
 export declare const NumberFromString: NumberFromString;
 /**
  * Type-level representation of {@link FiniteFromString}.
  *
- * @category Number
+ * @category models
  * @since 4.0.0
  */
 export interface FiniteFromString extends decodeTo<Finite, String> {
@@ -8467,14 +8418,14 @@ export interface FiniteFromString extends decodeTo<Finite, String> {
  * Encoding:
  * - A finite number is encoded as a `string`.
  *
- * @category Number
+ * @category schemas
  * @since 4.0.0
  */
 export declare const FiniteFromString: FiniteFromString;
 /**
  * Type-level representation of {@link BigIntFromString}.
  *
- * @category BigInt
+ * @category models
  * @since 4.0.0
  */
 export interface BigIntFromString extends decodeTo<BigInt, String> {
@@ -8505,14 +8456,14 @@ export interface BigIntFromString extends decodeTo<BigInt, String> {
  * @see {@link NumberFromString} for parsing JavaScript number strings, including non-finite values
  * @see {@link BigDecimalFromString} for parsing decimal number strings
  *
- * @category BigInt
+ * @category schemas
  * @since 4.0.0
  */
 export declare const BigIntFromString: BigIntFromString;
 /**
  * Type-level representation of {@link Trimmed}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface Trimmed extends String {
@@ -8521,14 +8472,14 @@ export interface Trimmed extends String {
 /**
  * Schema for strings that contains no leading or trailing whitespaces.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export declare const Trimmed: Trimmed;
 /**
  * Type-level representation of {@link Trim}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface Trim extends decodeTo<Trimmed, String> {
@@ -8545,14 +8496,14 @@ export interface Trim extends decodeTo<Trimmed, String> {
  * Encoding:
  * - The trimmed string is encoded as is.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export declare const Trim: Trim;
 /**
  * Type-level representation of {@link StringFromBase64}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface StringFromBase64 extends decodeTo<String, String> {
@@ -8569,14 +8520,14 @@ export interface StringFromBase64 extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a base64-encoded string.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export declare const StringFromBase64: StringFromBase64;
 /**
  * Type-level representation of {@link StringFromBase64Url}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface StringFromBase64Url extends decodeTo<String, String> {
@@ -8593,14 +8544,14 @@ export interface StringFromBase64Url extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a base64 (URL) encoded string.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export declare const StringFromBase64Url: StringFromBase64Url;
 /**
  * Type-level representation of {@link StringFromHex}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface StringFromHex extends decodeTo<String, String> {
@@ -8617,14 +8568,14 @@ export interface StringFromHex extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a hex string.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export declare const StringFromHex: StringFromHex;
 /**
  * Type-level representation of {@link StringFromUriComponent}.
  *
- * @category string
+ * @category models
  * @since 3.12.0
  */
 export interface StringFromUriComponent extends decodeTo<String, String> {
@@ -8644,7 +8595,7 @@ export interface StringFromUriComponent extends decodeTo<String, String> {
  *
  * **Example** (Decoding URI component strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const PaginationSchema = Schema.Struct({
@@ -8656,11 +8607,10 @@ export interface StringFromUriComponent extends decodeTo<String, String> {
  *   Schema.decodeTo(Schema.fromJsonString(PaginationSchema))
  * )
  *
- * console.log(Schema.encodeSync(UrlSchema)({ maxItemPerPage: 10, page: 1 }))
- * // %7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D
+ * Schema.encodeSync(UrlSchema)({ maxItemPerPage: 10, page: 1 }) // => "%7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D"
  * ```
  *
- * @category string
+ * @category schemas
  * @since 3.12.0
  */
 export declare const StringFromUriComponent: StringFromUriComponent;
@@ -8668,7 +8618,7 @@ export declare const StringFromUriComponent: StringFromUriComponent;
  * Schema for property keys accepted by Effect schemas: finite `number`,
  * `symbol`, or `string`.
  *
- * @category PropertyKey
+ * @category schemas
  * @since 4.0.0
  */
 export declare const PropertyKey: Union<readonly [Finite, Symbol, String]>;
@@ -8680,7 +8630,7 @@ export declare const PropertyKey: Union<readonly [Finite, Symbol, String]>;
  * The result contains an `issues` array where each issue has a message and an
  * optional path made of property keys or keyed path segments.
  *
- * @category Standard Schema
+ * @category schemas
  * @since 4.0.0
  */
 export declare const StandardSchemaV1FailureResult: Struct<{
@@ -8694,7 +8644,7 @@ export declare const StandardSchemaV1FailureResult: Struct<{
 /**
  * Type-level representation of {@link BooleanFromBit}.
  *
- * @category boolean
+ * @category models
  * @since 4.0.0
  */
 export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0, 1]>> {
@@ -8716,14 +8666,14 @@ export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0,
  * @see {@link Boolean} for validating values that are already booleans
  * @see {@link Literals} for keeping bit literals instead of decoding them
  *
- * @category boolean
+ * @category schemas
  * @since 4.0.0
  */
 export declare const BooleanFromBit: BooleanFromBit;
 /**
  * Type-level representation of {@link Uint8Array}.
  *
- * @category Uint8Array
+ * @category models
  * @since 4.0.0
  */
 export interface Uint8Array extends instanceOf<globalThis.Uint8Array<ArrayBufferLike>> {
@@ -8738,7 +8688,7 @@ export interface Uint8Array extends instanceOf<globalThis.Uint8Array<ArrayBuffer
  *
  * The default JSON serializer encodes Uint8Array as a Base64 encoded string.
  *
- * @category Uint8Array
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Uint8Array: Uint8Array;
@@ -8751,14 +8701,14 @@ export declare const Uint8Array: Uint8Array;
  *
  * @see {@link Uint8Array} for the corresponding schema
  *
- * @category Uint8Array
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Uint8ArrayReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link Uint8ArrayFromBase64}.
  *
- * @category Uint8Array
+ * @category models
  * @since 3.10.0
  */
 export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
@@ -8776,14 +8726,14 @@ export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
  * Encoding:
  * - A `Uint8Array` is encoded as a base64-encoded string.
  *
- * @category Uint8Array
+ * @category schemas
  * @since 3.10.0
  */
 export declare const Uint8ArrayFromBase64: Uint8ArrayFromBase64;
 /**
  * Type-level representation of {@link Uint8ArrayFromBase64Url}.
  *
- * @category Uint8Array
+ * @category models
  * @since 3.10.0
  */
 export interface Uint8ArrayFromBase64Url extends decodeTo<Uint8Array, String> {
@@ -8801,14 +8751,14 @@ export interface Uint8ArrayFromBase64Url extends decodeTo<Uint8Array, String> {
  * Encoding:
  * - A `Uint8Array` is encoded as a base64 (URL) encoded string.
  *
- * @category Uint8Array
+ * @category schemas
  * @since 3.10.0
  */
 export declare const Uint8ArrayFromBase64Url: Uint8ArrayFromBase64Url;
 /**
  * Type-level representation of {@link Uint8ArrayFromHex}.
  *
- * @category Uint8Array
+ * @category models
  * @since 3.10.0
  */
 export interface Uint8ArrayFromHex extends decodeTo<Uint8Array, String> {
@@ -8826,14 +8776,14 @@ export interface Uint8ArrayFromHex extends decodeTo<Uint8Array, String> {
  * Encoding:
  * - A `Uint8Array` is encoded as a hex encoded string.
  *
- * @category Uint8Array
+ * @category schemas
  * @since 3.10.0
  */
 export declare const Uint8ArrayFromHex: Uint8ArrayFromHex;
 /**
  * Type-level representation of {@link DateTimeUtc}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface DateTimeUtc extends declare<DateTime.Utc> {
@@ -8857,7 +8807,7 @@ export interface DateTimeUtc extends declare<DateTime.Utc> {
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
  * @see {@link DateTimeZoned} for preserving zoned DateTime values
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export declare const DateTimeUtc: DateTimeUtc;
@@ -8870,14 +8820,14 @@ export declare const DateTimeUtc: DateTimeUtc;
  *
  * @see {@link DateTimeUtc} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DateTimeUtcReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link DateTimeUtcFromDate}.
  *
- * @category DateTime
+ * @category models
  * @since 3.12.0
  */
 export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
@@ -8904,14 +8854,14 @@ export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
  * @see {@link Date} for validating Date instances without converting them
  *
- * @category DateTime
+ * @category schemas
  * @since 3.12.0
  */
 export declare const DateTimeUtcFromDate: DateTimeUtcFromDate;
 /**
  * Type-level representation of {@link DateTimeUtcFromString}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface DateTimeUtcFromString extends decodeTo<DateTimeUtc, String> {
@@ -8935,14 +8885,14 @@ export interface DateTimeUtcFromString extends decodeTo<DateTimeUtc, String> {
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
  * @see {@link DateFromString} for decoding strings into JavaScript Date instances
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DateTimeUtcFromString: DateTimeUtcFromString;
 /**
  * Type-level representation of {@link DateTimeUtcFromMillis}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>, Int> {
@@ -8963,14 +8913,14 @@ export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>
  * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
  * @see {@link DateFromMillis} for decoding epoch milliseconds into JavaScript Date instances
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DateTimeUtcFromMillis: DateTimeUtcFromMillis;
 /**
  * Type-level representation of {@link TimeZoneOffset}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface TimeZoneOffset extends declare<DateTime.TimeZone.Offset> {
@@ -8985,7 +8935,7 @@ export interface TimeZoneOffset extends declare<DateTime.TimeZone.Offset> {
  *
  * - encodes `DateTime.TimeZone.Offset` as a number (offset in milliseconds)
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export declare const TimeZoneOffset: TimeZoneOffset;
@@ -8998,14 +8948,14 @@ export declare const TimeZoneOffset: TimeZoneOffset;
  *
  * @see {@link TimeZoneOffset} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const TimeZoneOffsetReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link TimeZoneNamed}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface TimeZoneNamed extends declare<DateTime.TimeZone.Named> {
@@ -9020,7 +8970,7 @@ export interface TimeZoneNamed extends declare<DateTime.TimeZone.Named> {
  *
  * - encodes `DateTime.TimeZone.Named` as a string (IANA time zone identifier)
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export declare const TimeZoneNamed: TimeZoneNamed;
@@ -9033,14 +8983,14 @@ export declare const TimeZoneNamed: TimeZoneNamed;
  *
  * @see {@link TimeZoneNamed} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const TimeZoneNamedReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link TimeZoneNamedFromString}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface TimeZoneNamedFromString extends decodeTo<TimeZoneNamed, String> {
@@ -9057,14 +9007,14 @@ export interface TimeZoneNamedFromString extends decodeTo<TimeZoneNamed, String>
  * Encoding:
  * - A `DateTime.TimeZone.Named` is encoded as a `string`.
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const TimeZoneNamedFromString: TimeZoneNamedFromString;
 /**
  * Type-level representation of {@link TimeZone}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface TimeZone extends declare<DateTime.TimeZone> {
@@ -9080,7 +9030,7 @@ export interface TimeZone extends declare<DateTime.TimeZone> {
  * - encodes `DateTime.TimeZone` as a string (IANA identifier or offset like
  *   `+03:00`)
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export declare const TimeZone: TimeZone;
@@ -9093,14 +9043,14 @@ export declare const TimeZone: TimeZone;
  *
  * @see {@link TimeZone} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const TimeZoneReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link TimeZoneFromString}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface TimeZoneFromString extends decodeTo<TimeZone, String> {
@@ -9117,14 +9067,14 @@ export interface TimeZoneFromString extends decodeTo<TimeZone, String> {
  * Encoding:
  * - A `DateTime.TimeZone` is encoded as a `string`.
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const TimeZoneFromString: TimeZoneFromString;
 /**
  * Type-level representation of {@link DateTimeZoned}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface DateTimeZoned extends declare<DateTime.Zoned> {
@@ -9142,7 +9092,7 @@ export interface DateTimeZoned extends declare<DateTime.Zoned> {
  * - encodes named zones by appending the IANA identifier in brackets, such as
  *   `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export declare const DateTimeZoned: DateTimeZoned;
@@ -9155,14 +9105,14 @@ export declare const DateTimeZoned: DateTimeZoned;
  *
  * @see {@link DateTimeZoned} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DateTimeZonedReviver: SchemaRepresentation.DeclarationReviver<null>;
 /**
  * Type-level representation of {@link DateTimeZonedFromString}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface DateTimeZonedFromString extends decodeTo<DateTimeZoned, String> {
@@ -9179,7 +9129,7 @@ export interface DateTimeZonedFromString extends decodeTo<DateTimeZoned, String>
  * Encoding:
  * - A `DateTime.Zoned` is encoded as a `string`.
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export declare const DateTimeZonedFromString: DateTimeZonedFromString;
@@ -9264,13 +9214,23 @@ type MissingSelfGeneric<Usage extends string> = `Missing \`Self\` generic - use
  * Pass the desired class type as the first type parameter. The second optional
  * type parameter can be used to add nominal brands.
  *
+ * The `identifier` is the schema's stable runtime name. It is exposed on the
+ * class, stored in the schema AST, and used to label diagnostics and generated
+ * references as well as to format class instances.
+ *
+ * It also derives a runtime marker that recognizes instances across hot module
+ * reloads, where `instanceof` can fail because the constructor has been
+ * replaced. The identifier is explicit because the outer JavaScript class name
+ * is not available while the `extends` expression is evaluated and may change
+ * through renaming or minification.
+ *
  * **Gotchas**
  *
  * Passing `disableChecks` in the options skips constructor validation.
  *
  * **Example** (Defining a basic class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * class Person extends Schema.Class<Person>("Person")({
@@ -9279,13 +9239,13 @@ type MissingSelfGeneric<Usage extends string> = `Missing \`Self\` generic - use
  * }) {}
  *
  * const alice = new Person({ name: "Alice", age: 30 })
- * console.log(alice.name) // "Alice"
- * console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
+ * alice.name // => "Alice"
+ * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
  * ```
  *
  * **Example** (Extending a class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * class Animal extends Schema.Class<Animal>("Animal")({
@@ -9297,8 +9257,8 @@ type MissingSelfGeneric<Usage extends string> = `Missing \`Self\` generic - use
  * }) {}
  *
  * const dog = new Dog({ name: "Rex", breed: "Labrador" })
- * console.log(dog.name) // "Rex"
- * console.log(dog.breed) // "Labrador"
+ * dog.name // => "Rex"
+ * dog.breed // => "Labrador"
  * ```
  *
  * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
@@ -9324,13 +9284,23 @@ export declare const Class: {
      * Pass the desired class type as the first type parameter. The second optional
      * type parameter can be used to add nominal brands.
      *
+     * The `identifier` is the schema's stable runtime name. It is exposed on the
+     * class, stored in the schema AST, and used to label diagnostics and generated
+     * references as well as to format class instances.
+     *
+     * It also derives a runtime marker that recognizes instances across hot module
+     * reloads, where `instanceof` can fail because the constructor has been
+     * replaced. The identifier is explicit because the outer JavaScript class name
+     * is not available while the `extends` expression is evaluated and may change
+     * through renaming or minification.
+     *
      * **Gotchas**
      *
      * Passing `disableChecks` in the options skips constructor validation.
      *
      * **Example** (Defining a basic class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Person extends Schema.Class<Person>("Person")({
@@ -9339,13 +9309,13 @@ export declare const Class: {
      * }) {}
      *
      * const alice = new Person({ name: "Alice", age: 30 })
-     * console.log(alice.name) // "Alice"
-     * console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
+     * alice.name // => "Alice"
+     * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
      * ```
      *
      * **Example** (Extending a class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Animal extends Schema.Class<Animal>("Animal")({
@@ -9357,8 +9327,8 @@ export declare const Class: {
      * }) {}
      *
      * const dog = new Dog({ name: "Rex", breed: "Labrador" })
-     * console.log(dog.name) // "Rex"
-     * console.log(dog.breed) // "Labrador"
+     * dog.name // => "Rex"
+     * dog.breed // => "Labrador"
      * ```
      *
      * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
@@ -9384,13 +9354,23 @@ export declare const Class: {
          * Pass the desired class type as the first type parameter. The second optional
          * type parameter can be used to add nominal brands.
          *
+         * The `identifier` is the schema's stable runtime name. It is exposed on the
+         * class, stored in the schema AST, and used to label diagnostics and generated
+         * references as well as to format class instances.
+         *
+         * It also derives a runtime marker that recognizes instances across hot module
+         * reloads, where `instanceof` can fail because the constructor has been
+         * replaced. The identifier is explicit because the outer JavaScript class name
+         * is not available while the `extends` expression is evaluated and may change
+         * through renaming or minification.
+         *
          * **Gotchas**
          *
          * Passing `disableChecks` in the options skips constructor validation.
          *
          * **Example** (Defining a basic class)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Schema } from "effect"
          *
          * class Person extends Schema.Class<Person>("Person")({
@@ -9399,13 +9379,13 @@ export declare const Class: {
          * }) {}
          *
          * const alice = new Person({ name: "Alice", age: 30 })
-         * console.log(alice.name) // "Alice"
-         * console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
+         * alice.name // => "Alice"
+         * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
          * ```
          *
          * **Example** (Extending a class)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Schema } from "effect"
          *
          * class Animal extends Schema.Class<Animal>("Animal")({
@@ -9417,8 +9397,8 @@ export declare const Class: {
          * }) {}
          *
          * const dog = new Dog({ name: "Rex", breed: "Labrador" })
-         * console.log(dog.name) // "Rex"
-         * console.log(dog.breed) // "Labrador"
+         * dog.name // => "Rex"
+         * dog.breed // => "Labrador"
          * ```
          *
          * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
@@ -9444,13 +9424,23 @@ export declare const Class: {
          * Pass the desired class type as the first type parameter. The second optional
          * type parameter can be used to add nominal brands.
          *
+         * The `identifier` is the schema's stable runtime name. It is exposed on the
+         * class, stored in the schema AST, and used to label diagnostics and generated
+         * references as well as to format class instances.
+         *
+         * It also derives a runtime marker that recognizes instances across hot module
+         * reloads, where `instanceof` can fail because the constructor has been
+         * replaced. The identifier is explicit because the outer JavaScript class name
+         * is not available while the `extends` expression is evaluated and may change
+         * through renaming or minification.
+         *
          * **Gotchas**
          *
          * Passing `disableChecks` in the options skips constructor validation.
          *
          * **Example** (Defining a basic class)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Schema } from "effect"
          *
          * class Person extends Schema.Class<Person>("Person")({
@@ -9459,13 +9449,13 @@ export declare const Class: {
          * }) {}
          *
          * const alice = new Person({ name: "Alice", age: 30 })
-         * console.log(alice.name) // "Alice"
-         * console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
+         * alice.name // => "Alice"
+         * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
          * ```
          *
          * **Example** (Extending a class)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Schema } from "effect"
          *
          * class Animal extends Schema.Class<Animal>("Animal")({
@@ -9477,8 +9467,8 @@ export declare const Class: {
          * }) {}
          *
          * const dog = new Dog({ name: "Rex", breed: "Labrador" })
-         * console.log(dog.name) // "Rex"
-         * console.log(dog.breed) // "Labrador"
+         * dog.name // => "Rex"
+         * dog.breed // => "Labrador"
          * ```
          *
          * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
@@ -9506,7 +9496,7 @@ export declare const Class: {
  *
  * **Example** (Defining a tagged class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
@@ -9514,8 +9504,8 @@ export declare const Class: {
  * }) {}
  *
  * const c = new Circle({ radius: 5 })
- * console.log(c._tag) // "Circle"
- * console.log(c.radius) // 5
+ * c._tag // => "Circle"
+ * c.radius // => 5
  * ```
  *
  * @category constructors
@@ -9537,7 +9527,7 @@ export declare const TaggedClass: {
      *
      * **Example** (Defining a tagged class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
@@ -9545,8 +9535,8 @@ export declare const TaggedClass: {
      * }) {}
      *
      * const c = new Circle({ radius: 5 })
-     * console.log(c._tag) // "Circle"
-     * console.log(c.radius) // 5
+     * c._tag // => "Circle"
+     * c.radius // => 5
      * ```
      *
      * @category constructors
@@ -9568,7 +9558,7 @@ export declare const TaggedClass: {
          *
          * **Example** (Defining a tagged class)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Schema } from "effect"
          *
          * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
@@ -9576,8 +9566,8 @@ export declare const TaggedClass: {
          * }) {}
          *
          * const c = new Circle({ radius: 5 })
-         * console.log(c._tag) // "Circle"
-         * console.log(c.radius) // 5
+         * c._tag // => "Circle"
+         * c.radius // => 5
          * ```
          *
          * @category constructors
@@ -9599,7 +9589,7 @@ export declare const TaggedClass: {
          *
          * **Example** (Defining a tagged class)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Schema } from "effect"
          *
          * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
@@ -9607,8 +9597,8 @@ export declare const TaggedClass: {
          * }) {}
          *
          * const c = new Circle({ radius: 5 })
-         * console.log(c._tag) // "Circle"
-         * console.log(c.radius) // 5
+         * c._tag // => "Circle"
+         * c.radius // => 5
          * ```
          *
          * @category constructors
@@ -9629,7 +9619,7 @@ export declare const TaggedClass: {
  *
  * **Example** (Schema-backed error)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
@@ -9639,6 +9629,8 @@ export declare const TaggedClass: {
  * const program = Effect.gen(function*() {
  *   yield* new NotFound({ id: 1 })
  * })
+ * const error = await Effect.runPromise(Effect.flip(program))
+ * error.id // => 1
  * ```
  *
  * @category constructors
@@ -9653,7 +9645,7 @@ export declare const ErrorClass: {
      *
      * **Example** (Schema-backed error)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
      * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
@@ -9663,6 +9655,8 @@ export declare const ErrorClass: {
      * const program = Effect.gen(function*() {
      *   yield* new NotFound({ id: 1 })
      * })
+     * const error = await Effect.runPromise(Effect.flip(program))
+     * error.id // => 1
      * ```
      *
      * @category constructors
@@ -9677,7 +9671,7 @@ export declare const ErrorClass: {
          *
          * **Example** (Schema-backed error)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Effect, Schema } from "effect"
          *
          * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
@@ -9687,6 +9681,8 @@ export declare const ErrorClass: {
          * const program = Effect.gen(function*() {
          *   yield* new NotFound({ id: 1 })
          * })
+         * const error = await Effect.runPromise(Effect.flip(program))
+         * error.id // => 1
          * ```
          *
          * @category constructors
@@ -9701,7 +9697,7 @@ export declare const ErrorClass: {
          *
          * **Example** (Schema-backed error)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Effect, Schema } from "effect"
          *
          * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
@@ -9711,6 +9707,8 @@ export declare const ErrorClass: {
          * const program = Effect.gen(function*() {
          *   yield* new NotFound({ id: 1 })
          * })
+         * const error = await Effect.runPromise(Effect.flip(program))
+         * error.id // => 1
          * ```
          *
          * @category constructors
@@ -9730,7 +9728,7 @@ export declare const ErrorClass: {
  *
  * **Example** (Defining a tagged error class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
@@ -9740,6 +9738,9 @@ export declare const ErrorClass: {
  * const program = Effect.gen(function*() {
  *   yield* new NotFound({ id: 42 })
  * })
+ * const error = await Effect.runPromise(Effect.flip(program))
+ * error._tag // => "NotFound"
+ * error.id // => 42
  * ```
  *
  * @category constructors
@@ -9757,7 +9758,7 @@ export declare const TaggedErrorClass: {
      *
      * **Example** (Defining a tagged error class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
      * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
@@ -9767,6 +9768,9 @@ export declare const TaggedErrorClass: {
      * const program = Effect.gen(function*() {
      *   yield* new NotFound({ id: 42 })
      * })
+     * const error = await Effect.runPromise(Effect.flip(program))
+     * error._tag // => "NotFound"
+     * error.id // => 42
      * ```
      *
      * @category constructors
@@ -9784,7 +9788,7 @@ export declare const TaggedErrorClass: {
          *
          * **Example** (Defining a tagged error class)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Effect, Schema } from "effect"
          *
          * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
@@ -9794,6 +9798,9 @@ export declare const TaggedErrorClass: {
          * const program = Effect.gen(function*() {
          *   yield* new NotFound({ id: 42 })
          * })
+         * const error = await Effect.runPromise(Effect.flip(program))
+         * error._tag // => "NotFound"
+         * error.id // => 42
          * ```
          *
          * @category constructors
@@ -9811,7 +9818,7 @@ export declare const TaggedErrorClass: {
          *
          * **Example** (Defining a tagged error class)
          *
-         * ```ts
+         * ```ts import.meta.vitest
          * import { Effect, Schema } from "effect"
          *
          * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
@@ -9821,6 +9828,9 @@ export declare const TaggedErrorClass: {
          * const program = Effect.gen(function*() {
          *   yield* new NotFound({ id: 42 })
          * })
+         * const error = await Effect.runPromise(Effect.flip(program))
+         * error._tag // => "NotFound"
+         * error.id // => 42
          * ```
          *
          * @category constructors
@@ -9838,7 +9848,7 @@ export declare const TaggedErrorClass: {
  * Use this type when you need to defer instantiation of the arbitrary, for
  * example to support recursive schemas.
  *
- * @category Arbitrary
+ * @category utility types
  * @since 4.0.0
  */
 export type LazyArbitrary<T> = (fc: typeof FastCheck) => FastCheck.Arbitrary<T>;
@@ -9853,7 +9863,7 @@ export type LazyArbitrary<T> = (fc: typeof FastCheck) => FastCheck.Arbitrary<T>;
  * nodes, impossible constraints, invalid candidates, and recursive schemas
  * without a finite terminal path fail immediately.
  *
- * @category Arbitrary
+ * @category generators
  * @since 4.0.0
  */
 export declare function toArbitraryLazy<S extends Constraint>(schema: S): LazyArbitrary<S["Type"]>;
@@ -9870,7 +9880,7 @@ export declare function toArbitraryLazy<S extends Constraint>(schema: S): LazyAr
  *
  * **Example** (Generating arbitrary values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import * as FastCheck from "fast-check"
  *
@@ -9879,11 +9889,10 @@ export declare function toArbitraryLazy<S extends Constraint>(schema: S): LazyAr
  * )
  *
  * // Sample a random value
- * const sample = FastCheck.sample(PersonArb, 1)[0]
- * console.log(typeof sample.name) // "string"
+ * FastCheck.sample(PersonArb, 1)
  * ```
  *
- * @category Arbitrary
+ * @category generators
  * @since 4.0.0
  */
 export declare function toArbitrary<S extends Constraint>(schema: S): FastCheck.Arbitrary<S["Type"]>;
@@ -9899,7 +9908,7 @@ export declare function toArbitrary<S extends Constraint>(schema: S, options: {
  * The annotation is applied through this helper because adding it directly to
  * `Annotations.Bottom` would make schemas invariant.
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export declare function overrideToFormatter<S extends Top>(toFormatter: () => Formatter<S["Type"]>): (self: S) => S["Rebuild"];
@@ -9913,7 +9922,7 @@ export declare function overrideToFormatter<S extends Top>(toFormatter: () => Fo
  * The optional `onBefore` hook lets you intercept specific AST nodes before
  * the default formatting logic runs.
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export declare function toFormatter<S extends Constraint>(schema: S, options?: {
@@ -9939,13 +9948,13 @@ export declare function overrideToEquivalence<S extends Top>(toEquivalence: () =
  *
  * **Example** (Comparing structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const eq = Schema.toEquivalence(Schema.Struct({ id: Schema.Number, name: Schema.String }))
  *
- * console.log(eq({ id: 1, name: "Alice" }, { id: 1, name: "Alice" })) // true
- * console.log(eq({ id: 1, name: "Alice" }, { id: 2, name: "Alice" })) // false
+ * eq({ id: 1, name: "Alice" }, { id: 1, name: "Alice" }) // => true
+ * eq({ id: 1, name: "Alice" }, { id: 2, name: "Alice" }) // => false
  * ```
  *
  * @category instances
@@ -9960,7 +9969,7 @@ export declare function toEquivalence<T>(schema: Schema<T>): Equivalence.Equival
  *
  * Use {@link toType} before this function to represent the type side instead.
  *
- * @category Representation
+ * @category converting
  * @since 4.0.0
  */
 export declare function toRepresentation(schema: Constraint): SchemaRepresentation.Document;
@@ -10014,7 +10023,7 @@ export interface ToJsonSchemaOptions {
      *
      * **Example** (Including custom annotations)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * const schema = Schema.String.annotate({
@@ -10027,12 +10036,7 @@ export interface ToJsonSchemaOptions {
      *     key === "markdownDescription" || key.startsWith("x-")
      * })
      *
-     * console.log(doc.schema)
-     * // {
-     * //   type: "string",
-     * //   description: "A name",
-     * //   markdownDescription: "The **name** field"
-     * // }
+     * doc.schema // => { type: "string", description: "A name", markdownDescription: "The **name** field" }
      * ```
      */
     readonly includeAnnotationKey?: ((key: string) => boolean) | undefined;
@@ -10062,7 +10066,7 @@ export declare function toJsonSchemaDocument(schema: Constraint, options?: ToJso
 /**
  * Type-level representation returned by {@link toCodecJson}.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export interface toCodecJson<S extends Constraint> extends BottomLazy<S["ast"], toCodecJson<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -10087,7 +10091,7 @@ export interface toCodecJson<S extends Constraint> extends BottomLazy<S["ast"],
  * `toCodecJson` callback can return `undefined` when the declaration is already
  * in canonical JSON form.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export declare function toCodecJson<S extends Constraint>(schema: S): toCodecJson<S>;
@@ -10095,7 +10099,7 @@ export declare function toCodecJson<S extends Constraint>(schema: S): toCodecJso
  * Derives an isomorphism codec from a schema. The encoded form is the
  * schema's `Iso` type — the intermediate representation used for round-tripping.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export declare function toCodecIso<S extends Constraint>(schema: S): Codec<S["Type"], S["Iso"]>;
@@ -10103,14 +10107,14 @@ export declare function toCodecIso<S extends Constraint>(schema: S): Codec<S["Ty
  * A {@link Tree} of `string | undefined` nodes. Leaf values are either a
  * string representation or `undefined` for opaque/declaration types.
  *
- * @category Canonical Codecs
+ * @category models
  * @since 4.0.0
  */
 export type StringTree = Tree<string | undefined>;
 /**
  * Type-level representation returned by {@link toCodecStringTree}.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export interface toCodecStringTree<S extends Constraint> extends BottomLazy<S["ast"], toCodecStringTree<S>, ReadonlyArray<Constraint>, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -10133,14 +10137,14 @@ export interface toCodecStringTree<S extends Constraint> extends BottomLazy<S["a
  * `toCodec` encoding. A callback can return `undefined` when the declaration is
  * already in canonical StringTree form.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export declare function toCodecStringTree<S extends Constraint>(schema: S): toCodecStringTree<S>;
 /**
  * Type-level representation returned by {@link toCodecArrayFromSingle}.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export interface toCodecArrayFromSingle<S extends Constraint> extends BottomLazy<S["ast"], toCodecArrayFromSingle<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -10167,7 +10171,7 @@ export interface toCodecArrayFromSingle<S extends Constraint> extends BottomLazy
  * decoding convenience rather than a canonical StringTree representation. It
  * does not parse comma-separated strings.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export declare function toCodecArrayFromSingle<S extends Constraint>(schema: S): toCodecArrayFromSingle<S>;
@@ -10192,7 +10196,7 @@ type XmlEncoderOptions = {
  * an `Effect` that succeeds with the XML string or fails with `SchemaError` if
  * codec encoding fails.
  *
- * @category Canonical Codecs
+ * @category encoding
  * @since 4.0.0
  */
 export declare function toEncoderXml<T, RE>(codec: ConstraintCodec<T, unknown, unknown, RE>, options?: XmlEncoderOptions): (t: T) => Effect.Effect<string, SchemaError, RE>;
@@ -10205,7 +10209,7 @@ export declare function toEncoderXml<T, RE>(codec: ConstraintCodec<T, unknown, u
  *
  * @see {@link isGreaterThanDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanDateReviver: SchemaRepresentation.FilterReviver<{
@@ -10220,7 +10224,7 @@ export declare const isGreaterThanDateReviver: SchemaRepresentation.FilterRevive
  *
  * @see {@link isGreaterThanOrEqualToDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualToDateReviver: SchemaRepresentation.FilterReviver<{
@@ -10235,7 +10239,7 @@ export declare const isGreaterThanOrEqualToDateReviver: SchemaRepresentation.Fil
  *
  * @see {@link isLessThanDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanDateReviver: SchemaRepresentation.FilterReviver<{
@@ -10250,7 +10254,7 @@ export declare const isLessThanDateReviver: SchemaRepresentation.FilterReviver<{
  *
  * @see {@link isLessThanOrEqualToDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanOrEqualToDateReviver: SchemaRepresentation.FilterReviver<{
@@ -10265,7 +10269,7 @@ export declare const isLessThanOrEqualToDateReviver: SchemaRepresentation.Filter
  *
  * @see {@link isBetweenDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBetweenDateReviver: SchemaRepresentation.FilterReviver<{
@@ -10283,7 +10287,7 @@ export declare const isBetweenDateReviver: SchemaRepresentation.FilterReviver<{
  *
  * @see {@link isGreaterThanBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -10298,7 +10302,7 @@ export declare const isGreaterThanBigIntReviver: SchemaRepresentation.FilterRevi
  *
  * @see {@link isGreaterThanOrEqualToBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualToBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -10313,7 +10317,7 @@ export declare const isGreaterThanOrEqualToBigIntReviver: SchemaRepresentation.F
  *
  * @see {@link isLessThanBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -10328,7 +10332,7 @@ export declare const isLessThanBigIntReviver: SchemaRepresentation.FilterReviver
  *
  * @see {@link isLessThanOrEqualToBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isLessThanOrEqualToBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -10343,7 +10347,7 @@ export declare const isLessThanOrEqualToBigIntReviver: SchemaRepresentation.Filt
  *
  * @see {@link isBetweenBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export declare const isBetweenBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -10356,28 +10360,28 @@ export declare const isBetweenBigIntReviver: SchemaRepresentation.FilterReviver<
  * Derives an `Iso` optic from a schema that isomorphically converts between
  * the schema's `Type` and its `Iso` (intermediate / serialized form).
  *
- * @category Optic
+ * @category converting
  * @since 4.0.0
  */
 export declare function toIso<S extends Constraint>(schema: S): Optic_.Iso<S["Type"], S["Iso"]>;
 /**
  * Returns an identity `Iso` over the schema's source (`Type`) side.
  *
- * @category Optic
+ * @category constructors
  * @since 4.0.0
  */
 export declare function toIsoSource<S extends Constraint>(_: S): Optic_.Iso<S["Type"], S["Type"]>;
 /**
  * Returns an identity `Iso` over the schema's focus (`Iso`) side.
  *
- * @category Optic
+ * @category constructors
  * @since 4.0.0
  */
 export declare function toIsoFocus<S extends Constraint>(_: S): Optic_.Iso<S["Iso"], S["Iso"]>;
 /**
  * Type-level representation returned by {@link overrideToCodecIso}.
  *
- * @category Optic
+ * @category transforming
  * @since 4.0.0
  */
 export interface overrideToCodecIso<S extends Constraint, Iso> extends BottomLazy<S["ast"], overrideToCodecIso<S, Iso>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -10404,7 +10408,7 @@ export interface overrideToCodecIso<S extends Constraint, Iso> extends BottomLaz
  * provided `decode` and `encode` getters to transform between the schema type
  * and the target codec.
  *
- * @category Optic
+ * @category transforming
  * @since 4.0.0
  */
 export declare function overrideToCodecIso<S extends Constraint, Iso>(to: ConstraintCodec<Iso>, transformation: {
@@ -10424,7 +10428,7 @@ export declare function toDifferJsonPatch<T>(schema: ConstraintCodec<T, unknown>
  * Recursive tree type whose leaves are `Node` values and whose branches are
  * readonly arrays or string-keyed records of child trees.
  *
- * @category Tree
+ * @category models
  * @since 4.0.0
  */
 export type Tree<Node> = Node | TreeRecord<Node> | ReadonlyArray<Tree<Node>>;
@@ -10432,7 +10436,7 @@ export type Tree<Node> = Node | TreeRecord<Node> | ReadonlyArray<Tree<Node>>;
  * A record node in a {@link Tree}: an object mapping string keys to child
  * `Tree` nodes.
  *
- * @category Tree
+ * @category models
  * @since 4.0.0
  */
 export interface TreeRecord<A> {
@@ -10443,7 +10447,7 @@ export interface TreeRecord<A> {
  * The resulting schema accepts a single node value, an array of trees, or an
  * object whose values are trees.
  *
- * @category Tree
+ * @category schemas
  * @since 4.0.0
  */
 export declare function Tree<S extends Constraint>(node: S): Union<readonly [S, $Array<suspend<Codec<Tree<S["Type"]>, Tree<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"]>>>, $Record<String, suspend<Codec<Tree<S["Type"]>, Tree<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"]>>>]>;
@@ -10479,11 +10483,10 @@ export interface JsonObject {
  *
  * **Example** (Validating a JSON value)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option, Schema } from "effect"
  *
- * const result = Schema.decodeUnknownOption(Schema.Json)({ key: [1, true, null] })
- * console.log(result._tag) // "Some"
+ * Schema.decodeUnknownOption(Schema.Json)({ key: [1, true, null] }) // => Option.some({ key: [1, true, null] })
  * ```
  *
  * @category schemas
@@ -10555,7 +10558,7 @@ export declare const MutableJsonReviver: SchemaRepresentation.DeclarationReviver
  * annotations are taken from the last check; otherwise they are taken from
  * the base schema instance.
  *
- * @category Schema Resolvers
+ * @category getters
  * @since 4.0.0
  */
 export declare function resolveAnnotations<S extends Constraint>(schema: S): Annotations.Bottom<S["Type"], S["~type.parameters"]> | undefined;
@@ -10564,7 +10567,7 @@ export declare function resolveAnnotations<S extends Constraint>(schema: S): Ann
  * annotations are those attached via `annotateKey` and live on the AST's
  * `context` rather than on the schema node itself.
  *
- * @category Schema Resolvers
+ * @category getters
  * @since 4.0.0
  */
 export declare function resolveAnnotationsKey<S extends Constraint>(schema: S): Annotations.Key<S["Type"]> | undefined;
@@ -10594,7 +10597,7 @@ export declare namespace Annotations {
      *
      * **Example** (Defining your own annotations)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * // Extend the Annotations interface with a custom `version` annotation
@@ -10616,8 +10619,7 @@ export declare namespace Annotations {
      *
      * if (version) {
      *   // Access individual parts of the version
-     *   console.log(version[1])
-     *   // Output: 2
+     *   version[1] // => 2
      * }
      * ```
      *
@@ -10644,7 +10646,7 @@ export declare namespace Annotations {
          * `message` first, then `expected`, and finally falls back to `<filter>`.
          *
          * Use this to name a failed filter in the default message:
-         * `Expected <expected>, got <actual>`.
+         * `Expected <expected>`.
          */
         readonly expected?: string | undefined;
         readonly title?: string | undefined;
@@ -10700,7 +10702,7 @@ export declare namespace Annotations {
          * only changing the expected label. For a filter or refinement failure,
          * annotate the filter with `message` to replace the whole filter failure
          * message, or `expected` to keep the default
-         * `Expected <expected>, got <actual>` shape.
+         * `Expected <expected>` shape.
          */
         readonly message?: string | undefined;
         /**
@@ -10715,7 +10717,7 @@ export declare namespace Annotations {
          * Identifiers are used by schema tooling, including JSON Schema
          * generation, to name references. The default formatter also uses
          * `identifier` as the expected label for type-level failures, such as
-         * `Expected UserId, got null`.
+         * `Expected UserId`.
          *
          * `identifier` does not name a failed filter or refinement. If the base
          * type matches and a filter fails, put `expected` or `message` on the