effect 4.0.0-beta.66 → 4.0.0-beta.68

package/dist/Schema.d.ts

@@ -125,6 +125,7 @@ declare const TypeId = "~effect/Schema/Schema";
  * @see {@link optionalKey} — mark a struct field as optional
  * @see {@link optional} — mark a struct field as optional with `| undefined`
  *
+ * @category models
  * @since 4.0.0
  */
 export type Optionality = "required" | "optional";
@@ -133,6 +134,7 @@ export type Optionality = "required" | "optional";
  *
  * @see {@link mutableKey} — mark a struct field as mutable
  *
+ * @category models
  * @since 4.0.0
  */
 export type Mutability = "readonly" | "mutable";
@@ -142,6 +144,7 @@ export type Mutability = "readonly" | "mutable";
  * @see {@link withConstructorDefault} — add a default to a schema field
  * @see {@link tag} — creates a literal field with a constructor default
  *
+ * @category models
  * @since 4.0.0
  */
 export type ConstructorDefault = "no-default" | "with-default";
@@ -155,7 +158,8 @@ export type ConstructorDefault = "no-default" | "with-default";
  * @see {@link Bottom.makeEffect}
  * @see {@link Bottom.make}
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.13.4
  */
 export interface MakeOptions {
     /**
@@ -182,6 +186,7 @@ export interface MakeOptions {
  * @see {@link Schema} — tracks only the decoded Type
  * @see {@link Codec} — tracks Type + Encoded
  *
+ * @category models
  * @since 4.0.0
  */
 export interface Bottom<out T, out E, out RD, out RE, out Ast extends AST.AST, out Rebuild extends Top, out TypeMakeIn = T, out Iso = T, in out TypeParameters extends ReadonlyArray<Top> = readonly [], out TypeMake = TypeMakeIn, out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required"> extends Pipeable.Pipeable {
@@ -206,7 +211,7 @@ export interface Bottom<out T, out E, out RD, out RE, out Ast extends AST.AST, o
     check(...checks: readonly [AST.Check<this["Type"]>, ...Array<AST.Check<this["Type"]>>]): this["Rebuild"];
     rebuild(ast: this["ast"]): this["Rebuild"];
     /**
-     * @throws {Error} The issue is contained in the error cause.
+     * Constructs a value from the make input representation.
      */
     make(input: this["~type.make.in"], options?: MakeOptions): this["Type"];
     makeOption(input: this["~type.make.in"], options?: MakeOptions): Option_.Option<this["Type"]>;
@@ -217,7 +222,7 @@ export interface Bottom<out T, out E, out RD, out RE, out Ast extends AST.AST, o
  * type `T`, the encoded type `E`, and the list of type-parameter schemas
  * `TypeParameters`.
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<Top>, Iso = T> extends Bottom<T, E, TypeParameters[number]["DecodingServices"], TypeParameters[number]["EncodingServices"], AST.Declaration, declareConstructor<T, E, TypeParameters, Iso>, T, Iso, TypeParameters> {
@@ -239,10 +244,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
  * **Example** (Schema for a parametric `Box<A>` type)
  *
  * ```ts
- * import { Effect, Schema } from "effect"
- * import * as SchemaParser from "effect/SchemaParser"
- * import * as Issue from "effect/SchemaIssue"
- * import * as Option from "effect/Option"
+ * import { Effect, Option, Schema, SchemaIssue as Issue, SchemaParser } from "effect"
  *
  * interface Box<A> {
  *   readonly value: A
@@ -269,7 +271,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
  * const schema = Box(Schema.Number)
  * ```
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare function declareConstructor<T, E = T, Iso = T>(): <const TypeParameters extends ReadonlyArray<Top>>(typeParameters: TypeParameters, run: (typeParameters: { readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Type"], TypeParameters[K]["Encoded"]>; }) => (u: unknown, self: AST.Declaration, options: AST.ParseOptions) => Effect.Effect<T, Issue.Issue>, annotations?: Annotations.Declaration<T, TypeParameters>) => declareConstructor<T, E, TypeParameters, Iso>;
@@ -277,8 +279,8 @@ export declare function declareConstructor<T, E = T, Iso = T>(): <const TypePara
  * The schema type returned by {@link declare}, representing a non-parametric
  * opaque type `T` with no type parameters.
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.13.3
  */
 export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [], Iso> {
     readonly "Rebuild": declare<T, Iso>;
@@ -309,8 +311,8 @@ export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [
  *
  * @see {@link declareConstructor} for creating schemas for parametric types.
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function declare<T, Iso = T>(is: (u: unknown) => u is T, annotations?: Annotations.Declaration<T> | undefined): declare<T, Iso>;
 /**
@@ -337,6 +339,7 @@ export declare function declare<T, Iso = T>(is: (u: unknown) => u is T, annotati
  * type E = typeof bottom["Encoded"]  // string
  * ```
  *
+ * @category utils
  * @since 4.0.0
  */
 export declare function revealBottom<S extends Top>(bottom: S): Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], S["Rebuild"], S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]>;
@@ -363,7 +366,7 @@ export declare function revealBottom<S extends Top>(bottom: S): Bottom<S["Type"]
  *
  * @see {@link annotateEncoded} to annotate the encoded side instead.
  *
- * @category Annotations
+ * @category annotations
  * @since 4.0.0
  */
 export declare function annotate<S extends Top>(annotations: Annotations.Bottom<S["Type"], S["~type.parameters"]>): (self: S) => S["Rebuild"];
@@ -392,7 +395,7 @@ export declare function annotate<S extends Top>(annotations: Annotations.Bottom<
  *
  * @see {@link annotate} to annotate the type side instead.
  *
- * @category Annotations
+ * @category annotations
  * @since 4.0.0
  */
 export declare function annotateEncoded<S extends Top>(annotations: Annotations.Bottom<S["Encoded"], readonly []>): (self: S) => S["Rebuild"];
@@ -421,7 +424,7 @@ export declare function annotateEncoded<S extends Top>(annotations: Annotations.
  * })
  * ```
  *
- * @category Annotations
+ * @category annotations
  * @since 4.0.0
  */
 export declare function annotateKey<S extends Top>(annotations: Annotations.Key<S["Type"]>): (self: S) => S["Rebuild"];
@@ -438,6 +441,7 @@ export declare function annotateKey<S extends Top>(annotations: Annotations.Key<
  * - {@link Decoder}`<T, RD>` — for decode-only APIs
  * - {@link Encoder}`<E, RE>` — for encode-only APIs
  *
+ * @category models
  * @since 4.0.0
  */
 export interface Top extends Bottom<unknown, unknown, unknown, unknown, AST.AST, Top, unknown, unknown, any, // this is because TypeParameters is invariant
@@ -446,7 +450,7 @@ unknown, Mutability, Optionality, ConstructorDefault, Mutability, Optionality> {
 /**
  * Namespace of type-level helpers for {@link Schema}.
  *
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare namespace Schema {
     /**
@@ -462,7 +466,8 @@ export declare namespace Schema {
      * // { readonly name: string; readonly age: number }
      * ```
      *
-     * @since 4.0.0
+     * @category utility types
+     * @since 3.10.0
      */
     type Type<S> = S extends Top ? S["Type"] : never;
 }
@@ -491,7 +496,8 @@ export declare namespace Schema {
  * @see {@link Codec} — also tracks Encoded, DecodingServices, EncodingServices
  * @see {@link Schema.Type} — extract the decoded type at the type level
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Schema<out T> extends Top {
     readonly "Type": T;
@@ -516,7 +522,8 @@ export declare namespace Codec {
      * // string
      * ```
      *
-     * @since 4.0.0
+     * @category utility types
+     * @since 3.10.0
      */
     type Encoded<S> = S extends Top ? S["Encoded"] : never;
     /**
@@ -532,6 +539,7 @@ export declare namespace Codec {
      * // never
      * ```
      *
+     * @category utility types
      * @since 4.0.0
      */
     type DecodingServices<S> = S extends Top ? S["DecodingServices"] : never;
@@ -548,19 +556,10 @@ export declare namespace Codec {
      * // never
      * ```
      *
+     * @category utility types
      * @since 4.0.0
      */
     type EncodingServices<S> = S extends Top ? S["EncodingServices"] : never;
-    /**
-     * Converts a schema type into an assertion function signature. The resulting
-     * function narrows its argument to `I & S["Type"]`. Only schemas with
-     * `DecodingServices: never` (i.e. no required services) can be used here.
-     *
-     * Produced by {@link asserts}.
-     *
-     * @since 4.0.0
-     */
-    type ToAsserts<S extends Top> = <I>(input: I) => asserts input is I & S["Type"];
 }
 /**
  * A schema that additionally supports optic (lens/prism) operations.
@@ -575,6 +574,7 @@ export declare namespace Codec {
  * `Optic` automatically. You normally interact with this interface through
  * {@link Optic_} utilities rather than constructing it directly.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface Optic<out T, out Iso> extends Schema<T> {
@@ -611,6 +611,7 @@ export interface Optic<out T, out Iso> extends Schema<T> {
  * @see {@link Codec.EncodingServices} — extract required encoding services
  * @see {@link revealCodec} — helper to make TypeScript infer the full Codec type
  *
+ * @category models
  * @since 4.0.0
  */
 export interface Codec<out T, out E = T, out RD = never, out RE = never> extends Schema<T> {
@@ -637,6 +638,7 @@ export interface Codec<out T, out E = T, out RD = never, out RE = never> extends
  * validate(Schema.NumberFromString) // ok
  * ```
  *
+ * @category models
  * @since 4.0.0
  */
 export interface Decoder<out T, out RD = never> extends Codec<T, unknown, RD, unknown> {
@@ -660,6 +662,7 @@ export interface Decoder<out T, out RD = never> extends Codec<T, unknown, RD, un
  * serialize(Schema.NumberFromString) // ok — encodes number to string
  * ```
  *
+ * @category models
  * @since 4.0.0
  */
 export interface Encoder<out E, out RE = never> extends Codec<unknown, E, unknown, RE> {
@@ -685,6 +688,7 @@ export interface Encoder<out E, out RE = never> extends Codec<unknown, E, unknow
  * type Enc = typeof codec["Encoded"] // string
  * ```
  *
+ * @category utils
  * @since 4.0.0
  */
 export declare function revealCodec<T, E, RD, RE>(codec: Codec<T, E, RD, RE>): Codec<T, E, RD, RE>;
@@ -735,6 +739,7 @@ SchemaError };
  * }
  * ```
  *
+ * @category guards
  * @since 4.0.0
  */
 export declare function isSchemaError(u: unknown): u is SchemaError;
@@ -811,7 +816,6 @@ export declare function toStandardSchemaV1<S extends Decoder<unknown>>(self: S,
  *
  * @category Standard Schema
  * @since 4.0.0
- * @experimental
  */
 export declare function toStandardJSONSchemaV1<S extends Top>(self: S): StandardJSONSchemaV1<S["Encoded"], S["Type"]> & S;
 /**
@@ -840,8 +844,8 @@ export declare function toStandardJSONSchemaV1<S extends Top>(self: S): Standard
  * }
  * ```
  *
- * @category Asserting
- * @since 4.0.0
+ * @category guards
+ * @since 3.10.0
  */
 export declare const is: typeof Parser.is;
 /**
@@ -857,128 +861,157 @@ export declare const is: typeof Parser.is;
  * ```ts
  * import { Schema } from "effect"
  *
- * const assertString: (u: unknown) => asserts u is string = Schema.asserts(
- *   Schema.String
- * )
+ * const input: unknown = "hello"
  *
- * // This will pass silently (no return value)
- * try {
- *   assertString("hello")
- *   console.log("String assertion passed")
- * } catch (error) {
- *   console.log("String assertion failed")
- * }
+ * // This will pass silently (no return value) and narrow input to string
+ * Schema.asserts(Schema.String, input)
+ * console.log(input.toUpperCase())
  *
  * // This will throw an error
  * try {
- *   assertString(123)
+ *   const invalid: unknown = 123
+ *   Schema.asserts(Schema.String, invalid)
  * } catch (error) {
  *   console.log("Non-string assertion failed as expected")
  * }
  * ```
  *
- * @category Asserting
+ * @category guards
  * @since 4.0.0
  */
-export declare const asserts: typeof Parser.asserts;
+export declare const asserts: <S extends Top, I>(schema: S, input: I) => asserts input is I & S["Type"];
 /**
  * Decodes an `unknown` input against a schema, returning an `Effect` that
  * succeeds with the decoded value or fails with a {@link SchemaError}. Use this
  * when the input type is not statically known. Prefer {@link decodeEffect} when
  * the input is already typed as the schema's `Encoded` type.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownEffect<S extends Top>(schema: S): (input: unknown, options?: AST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
+export declare function decodeUnknownEffect<S extends Top>(schema: S, options?: AST.ParseOptions): (input: unknown, options?: AST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
  * returning an `Effect` that succeeds with the decoded value or fails with a
  * {@link SchemaError}. Use this when the input is already typed; for `unknown`
  * input use {@link decodeUnknownEffect}.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
-export declare const decodeEffect: <S extends Top>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
+export declare const decodeEffect: <S extends Top>(schema: S, options?: AST.ParseOptions) => (input: S["Encoded"], options?: AST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
 /**
  * Decodes an `unknown` input against a schema synchronously, returning an
  * `Exit` that is either a `Success` with the decoded value or a `Failure` with
  * a {@link SchemaError}. Only usable with schemas that have no
  * `DecodingServices` requirement. Prefer {@link decodeExit} when the input is
  * already typed as the schema's `Encoded` type.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
+export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema
  * synchronously, returning an `Exit` that is either a `Success` with the
  * decoded value or a `Failure` with a {@link SchemaError}. Only usable with
  * schemas that have no `DecodingServices` requirement. For `unknown` input use
  * {@link decodeUnknownExit}.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
-export declare const decodeExit: <S extends Decoder<unknown>>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
+export declare const decodeExit: <S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
 /**
  * Decodes an `unknown` input against a schema, returning an `Option` that is
  * `Some` with the decoded value on success or `None` on failure. Prefer this
  * over {@link decodeUnknownExit} or {@link decodeUnknownEffect} when you only
  * need to know whether decoding succeeded and don't need error details. For
  * typed input use {@link decodeOption}.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
  *
- * @category Decoding
- * @since 4.0.0
+ * @category decoding
+ * @since 3.10.0
  */
 export declare const decodeUnknownOption: typeof Parser.decodeUnknownOption;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
  * returning an `Option` that is `Some` with the decoded value on success or
  * `None` on failure. For `unknown` input use {@link decodeUnknownOption}.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
  *
- * @category Decoding
- * @since 4.0.0
+ * @category decoding
+ * @since 3.10.0
  */
-export declare const decodeOption: <S extends Decoder<unknown>>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Option_.Option<S["Type"]>;
+export declare const decodeOption: <S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Encoded"], options?: AST.ParseOptions) => Option_.Option<S["Type"]>;
 /**
- * Decodes an `unknown` input against a schema, returning a `Promise` that
- * resolves with the decoded value or rejects with a {@link SchemaError}. Useful
- * for integrating with Promise-based APIs. For typed input use
- * {@link decodePromise}.
+ * Decodes an `unknown` input against a schema, returning a `Result` that
+ * succeeds with the decoded value or fails with a schema issue. For typed input
+ * use {@link decodeResult}.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export declare const decodeUnknownResult: typeof Parser.decodeUnknownResult;
 /**
- * @category Decoding
+ * Decodes a typed input (the schema's `Encoded` type) against a schema,
+ * returning a `Result` that succeeds with the decoded value or fails with a
+ * schema issue. For `unknown` input use {@link decodeUnknownResult}.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
+ *
+ * @category decoding
  * @since 4.0.0
  */
-export declare const decodeResult: <S extends Decoder<unknown>>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => Result_.Result<S["Type"], Issue.Issue>;
+export declare const decodeResult: <S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Encoded"], options?: AST.ParseOptions) => Result_.Result<S["Type"], Issue.Issue>;
 /**
- * @category Decoding
- * @since 4.0.0
+ * Decodes an `unknown` input against a schema, returning a `Promise` that
+ * resolves with the decoded value or rejects with a schema issue. Useful for
+ * integrating with Promise-based APIs. For typed input use
+ * {@link decodePromise}.
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
+ *
+ * @category decoding
+ * @since 3.10.0
  */
 export declare const decodeUnknownPromise: typeof Parser.decodeUnknownPromise;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
  * returning a `Promise` that resolves with the decoded value or rejects with a
- * {@link SchemaError}. For `unknown` input use {@link decodeUnknownPromise}.
+ * schema issue. For `unknown` input use `decodeUnknownPromise`.
  *
- * @category Decoding
- * @since 4.0.0
+ * **Details**
+ * Options may be provided either when creating the decoder or when applying it;
+ * application options override creation options.
+ *
+ * @category decoding
+ * @since 3.10.0
  */
 export declare const decodePromise: typeof Parser.decodePromise;
 /**
- * Decodes an `unknown` input against a schema synchronously, throwing a
- * {@link SchemaError} on failure. Use this when you want to validate data at a
- * boundary and treat a schema mismatch as an unrecoverable error. For
- * non-throwing alternatives see {@link decodeUnknownOption},
- * {@link decodeUnknownExit}, or {@link decodeUnknownEffect}. For typed input
- * use {@link decodeSync}.
+ * Decodes an `unknown` input against a schema synchronously, returning the
+ * decoded value or throwing an `Error` whose cause contains the schema issue.
+ * Use this when you want to validate data at a boundary and treat a schema
+ * mismatch as an exception. For typed input use `decodeSync`.
+ *
+ * **Details**
+ * Only service-free schemas can be decoded synchronously. For non-throwing
+ * alternatives see `decodeUnknownOption`, `decodeUnknownExit`, or
+ * `decodeUnknownEffect`. Options may be provided either when creating the
+ * decoder or when applying it; application options override creation options.
  *
  * **Example** (Decoding with a transformation schema)
  *
@@ -997,24 +1030,31 @@ export declare const decodePromise: typeof Parser.decodePromise;
  * //         └─ Expected a numeric string, actual "not a number"
  * ```
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
 export declare const decodeUnknownSync: typeof Parser.decodeUnknownSync;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema
- * synchronously, throwing a {@link SchemaError} on failure. For `unknown` input
- * use {@link decodeUnknownSync}.
+ * synchronously, returning the decoded value or throwing an `Error` whose cause
+ * contains the schema issue. For `unknown` input use `decodeUnknownSync`.
+ *
+ * **Details**
+ * Only service-free schemas can be decoded synchronously. Options may be
+ * provided either when creating the decoder or when applying it; application
+ * options override creation options.
  *
- * @category Decoding
+ * @category decoding
  * @since 4.0.0
  */
-export declare const decodeSync: <S extends Decoder<unknown>>(schema: S) => (input: S["Encoded"], options?: AST.ParseOptions) => S["Type"];
+export declare const decodeSync: <S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Encoded"], options?: AST.ParseOptions) => S["Type"];
 /**
  * Encodes an `unknown` input against a schema, returning an `Effect` that
  * succeeds with the encoded value or fails with a {@link SchemaError}. Use this
  * when the input type is not statically known. Prefer {@link encodeEffect} when
  * the input is already typed as the schema's `Type`.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
  * **Example** (Encoding a value to a string)
  *
@@ -1027,91 +1067,117 @@ export declare const decodeSync: <S extends Decoder<unknown>>(schema: S) => (inp
  * // Output: "42"
  * ```
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownEffect<S extends Top>(schema: S): (input: unknown, options?: AST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
+export declare function encodeUnknownEffect<S extends Top>(schema: S, options?: AST.ParseOptions): (input: unknown, options?: AST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning an
  * `Effect` that succeeds with the encoded value or fails with a
  * {@link SchemaError}. Use this when the input is already typed; for `unknown`
  * input use {@link encodeUnknownEffect}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
-export declare const encodeEffect: <S extends Top>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
+export declare const encodeEffect: <S extends Top>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
 /**
  * Encodes an `unknown` input against a schema synchronously, returning an
  * `Exit` that is either a `Success` with the encoded value or a `Failure` with
  * a {@link SchemaError}. Only usable with schemas that have no
  * `EncodingServices` requirement. Prefer {@link encodeExit} when the input is
  * already typed as the schema's `Type`.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
+export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema synchronously,
  * returning an `Exit` that is either a `Success` with the encoded value or a
  * `Failure` with a {@link SchemaError}. Only usable with schemas that have no
  * `EncodingServices` requirement. For `unknown` input use
  * {@link encodeUnknownExit}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
-export declare const encodeExit: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
+export declare const encodeExit: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
 /**
  * Encodes an `unknown` input against a schema, returning an `Option` that is
  * `Some` with the encoded value on success or `None` on failure. Prefer this
  * over {@link encodeUnknownExit} or {@link encodeUnknownEffect} when you only
  * need to know whether encoding succeeded and don't need error details. For
  * typed input use {@link encodeOption}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
- * @since 4.0.0
+ * @category encoding
+ * @since 3.10.0
  */
 export declare const encodeUnknownOption: typeof Parser.encodeUnknownOption;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning an
  * `Option` that is `Some` with the encoded value on success or `None` on
  * failure. For `unknown` input use {@link encodeUnknownOption}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
- * @since 4.0.0
+ * @category encoding
+ * @since 3.10.0
  */
-export declare const encodeOption: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Option_.Option<S["Encoded"]>;
+export declare const encodeOption: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => Option_.Option<S["Encoded"]>;
 /**
- * Encodes an `unknown` input against a schema, returning a `Promise` that
- * resolves with the encoded value or rejects with a {@link SchemaError}. Useful
- * for integrating with Promise-based APIs. For typed input use
- * {@link encodePromise}.
+ * Encodes an `unknown` input against a schema, returning a `Result` that
+ * succeeds with the encoded value or fails with a schema issue. For typed input
+ * use {@link encodeResult}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export declare const encodeUnknownResult: typeof Parser.encodeUnknownResult;
 /**
- * @category Encoding
+ * Encodes a typed input (the schema's `Type`) against a schema, returning a
+ * `Result` that succeeds with the encoded value or fails with a schema issue.
+ * For `unknown` input use {@link encodeUnknownResult}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
+ *
+ * @category encoding
  * @since 4.0.0
  */
-export declare const encodeResult: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Result_.Result<S["Encoded"], Issue.Issue>;
+export declare const encodeResult: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => Result_.Result<S["Encoded"], Issue.Issue>;
 /**
- * @category Encoding
- * @since 4.0.0
+ * Encodes an `unknown` input against a schema, returning a `Promise` that
+ * resolves with the encoded value or rejects with a schema issue. Useful for
+ * integrating with Promise-based APIs. For typed input use
+ * {@link encodePromise}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
+ *
+ * @category encoding
+ * @since 3.10.0
  */
-export declare const encodeUnknownPromise: <S extends Encoder<unknown>>(schema: S) => (input: unknown, options?: AST.ParseOptions) => Promise<S["Encoded"]>;
+export declare const encodeUnknownPromise: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: unknown, options?: AST.ParseOptions) => Promise<S["Encoded"]>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning a
  * `Promise` that resolves with the encoded value or rejects with a
  * {@link SchemaError}. For `unknown` input use {@link encodeUnknownPromise}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
- * @since 4.0.0
+ * @category encoding
+ * @since 3.10.0
  */
-export declare const encodePromise: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => Promise<S["Encoded"]>;
+export declare const encodePromise: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => Promise<S["Encoded"]>;
 /**
  * Encodes an `unknown` input against a schema synchronously, throwing a
  * {@link SchemaError} on failure. Use this when you want to serialize data at a
@@ -1119,8 +1185,10 @@ export declare const encodePromise: <S extends Encoder<unknown>>(schema: S) => (
  * non-throwing alternatives see {@link encodeUnknownOption},
  * {@link encodeUnknownExit}, or {@link encodeUnknownEffect}. For typed input
  * use {@link encodeSync}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
 export declare const encodeUnknownSync: typeof Parser.encodeUnknownSync;
@@ -1128,11 +1196,13 @@ export declare const encodeUnknownSync: typeof Parser.encodeUnknownSync;
  * Encodes a typed input (the schema's `Type`) against a schema synchronously,
  * throwing a {@link SchemaError} on failure. For `unknown` input use
  * {@link encodeUnknownSync}.
+ * Options may be provided either when creating the encoder or when applying it;
+ * application options override creation options.
  *
- * @category Encoding
+ * @category encoding
  * @since 4.0.0
  */
-export declare const encodeSync: <S extends Encoder<unknown>>(schema: S) => (input: S["Type"], options?: AST.ParseOptions) => S["Encoded"];
+export declare const encodeSync: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => S["Encoded"];
 /**
  * Creates a schema from an AST (Abstract Syntax Tree) node.
  *
@@ -1145,8 +1215,8 @@ export declare const encodeSync: <S extends Encoder<unknown>>(schema: S) => (inp
  * the bridge between the untyped AST representation and the strongly-typed
  * schema.
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const make: <S extends Top>(ast: S["ast"], options?: object) => S;
 /**
@@ -1167,6 +1237,7 @@ export declare const make: <S extends Top>(ast: S["ast"], options?: object) => S
  * // "a"
  * ```
  *
+ * @category constructors
  * @since 4.0.0
  */
 export declare function asClass<S extends Top>(schema: S): S & {
@@ -1175,8 +1246,8 @@ export declare function asClass<S extends Top>(schema: S): S & {
 /**
  * Tests if a value is a `Schema`.
  *
- * @category Guards
- * @since 4.0.0
+ * @category guards
+ * @since 3.10.0
  */
 export declare function isSchema(u: unknown): u is Top;
 /**
@@ -1184,6 +1255,7 @@ export declare function isSchema(u: unknown): u is Top;
  * when present must match the wrapped schema (no implicit `undefined`).
  * Produced by {@link optionalKey}.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface optionalKey<S extends Top> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], optionalKey<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], "optional", S["~type.constructor.default"], S["~encoded.mutability"], "optional"> {
@@ -1212,6 +1284,7 @@ interface optionalKeyLambda extends Lambda {
  * type Person = typeof schema["Type"]
  * ```
  *
+ * @category combinators
  * @since 4.0.0
  */
 export declare const optionalKey: optionalKeyLambda;
@@ -1223,6 +1296,7 @@ interface requiredKeyLambda extends Lambda {
  * Reverses {@link optionalKey}, returning the inner required schema. Only
  * applicable to schemas already wrapped with `optionalKey`.
  *
+ * @category combinators
  * @since 4.0.0
  */
 export declare const requiredKey: requiredKeyLambda;
@@ -1230,7 +1304,8 @@ export declare const requiredKey: requiredKeyLambda;
  * Companion type for an optional struct key that also accepts `undefined`.
  * Equivalent to `optionalKey<UndefinedOr<S>>`. Produced by {@link optional}.
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface optional<S extends Top> extends optionalKey<UndefinedOr<S>> {
     readonly "Rebuild": optional<S>;
@@ -1262,7 +1337,8 @@ interface optionalLambda extends Lambda {
  * type Person = typeof schema.Type
  * ```
  *
- * @since 4.0.0
+ * @category combinators
+ * @since 3.10.0
  */
 export declare const optional: optionalLambda;
 interface requiredLambda extends Lambda {
@@ -1273,13 +1349,15 @@ interface requiredLambda extends Lambda {
  * Reverses {@link optional}, returning the inner schema (unwrapping `UndefinedOr`).
  * Only applicable to schemas already wrapped with `optional`.
  *
- * @since 4.0.0
+ * @category combinators
+ * @since 3.10.0
  */
 export declare const required: requiredLambda;
 /**
  * Companion type for a mutable struct key. The key's property is writable.
  * Produced by {@link mutableKey}.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface mutableKey<S extends Top> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], mutableKey<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], "mutable", S["~type.optionality"], S["~type.constructor.default"], "mutable", S["~encoded.optionality"]> {
@@ -1293,6 +1371,7 @@ interface mutableKeyLambda extends Lambda {
  * Makes a struct field mutable (removes the `readonly` modifier on the property).
  * Use {@link readonlyKey} to reverse.
  *
+ * @category combinators
  * @since 4.0.0
  */
 export declare const mutableKey: mutableKeyLambda;
@@ -1304,6 +1383,7 @@ interface readonlyKeyLambda extends Lambda {
  * Reverses {@link mutableKey}, returning the inner schema as readonly again.
  * Only applicable to schemas already wrapped with `mutableKey`.
  *
+ * @category combinators
  * @since 4.0.0
  */
 export declare const readonlyKey: readonlyKeyLambda;
@@ -1311,6 +1391,7 @@ export declare const readonlyKey: readonlyKeyLambda;
  * Schema type that collapses a transformation schema to its decoded `Type` on
  * both sides (Type = Encoded = S["Type"]). Produced by {@link toType}.
  *
+ * @category transforming
  * @since 4.0.0
  */
 export interface toType<S extends Top> extends Bottom<S["Type"], S["Type"], never, never, S["ast"], toType<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -1323,6 +1404,7 @@ interface toTypeLambda extends Lambda {
  * Extracts the type-side schema: sets `Encoded` to equal the decoded `Type`,
  * discarding the encoding transformation path.
  *
+ * @category transforming
  * @since 4.0.0
  */
 export declare const toType: toTypeLambda;
@@ -1330,6 +1412,7 @@ export declare const toType: toTypeLambda;
  * Schema type that collapses a transformation schema to its `Encoded` side on
  * both sides (Type = Encoded = S["Encoded"]). Produced by {@link toEncoded}.
  *
+ * @category transforming
  * @since 4.0.0
  */
 export interface toEncoded<S extends Top> extends Bottom<S["Encoded"], S["Encoded"], never, never, AST.AST, toEncoded<S>, S["Encoded"], S["Encoded"], ReadonlyArray<Top>, S["Encoded"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -1342,6 +1425,7 @@ interface toEncodedLambda extends Lambda {
  * Extracts the encoded-side schema: sets `Type` to equal the `Encoded`,
  * discarding the decoding transformation path.
  *
+ * @category transforming
  * @since 4.0.0
  */
 export declare const toEncoded: toEncodedLambda;
@@ -1350,6 +1434,7 @@ declare const FlipTypeId = "~effect/Schema/flip";
  * Schema type representing a flipped schema where `Type` and `Encoded` are
  * swapped. Produced by {@link flip}.
  *
+ * @category transforming
  * @since 4.0.0
  */
 export interface flip<S extends Top> extends Bottom<S["Encoded"], S["Type"], S["EncodingServices"], S["DecodingServices"], AST.AST, flip<S>, S["Encoded"], S["Encoded"], ReadonlyArray<Top>, S["Encoded"], S["~encoded.mutability"], S["~encoded.optionality"], ConstructorDefault, S["~type.mutability"], S["~type.optionality"]> {
@@ -1370,6 +1455,7 @@ export interface flip<S extends Top> extends Bottom<S["Encoded"], S["Type"], S["
  * // flipped: decodes number → string
  * ```
  *
+ * @category transforming
  * @since 4.0.0
  */
 export declare function flip<S extends Top>(schema: S): S extends flip<infer F> ? F["Rebuild"] : flip<S>;
@@ -1377,7 +1463,8 @@ export declare function flip<S extends Top>(schema: S): S extends flip<infer F>
  * Represents a schema for a single literal value.
  *
  * @see {@link Literal} for the constructor function.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Literal<L extends AST.LiteralValue> extends Bottom<L, L, never, never, AST.Literal, Literal<L>> {
     readonly literal: L;
@@ -1387,6 +1474,7 @@ export interface Literal<L extends AST.LiteralValue> extends Bottom<L, L, never,
  * Creates a schema for a single literal value (string, number, bigint, boolean, or null).
  *
  * **Example** (String literal)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -1397,36 +1485,58 @@ export interface Literal<L extends AST.LiteralValue> extends Bottom<L, L, never,
  * @see {@link Literals} for a schema that represents a union of literals.
  * @see {@link tag} for a schema that represents a literal value that can be
  * used as a discriminator field in tagged unions and has a constructor default.
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function Literal<L extends AST.LiteralValue>(literal: L): Literal<L>;
 /**
  * Namespace for {@link TemplateLiteral} helper types.
  *
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare namespace TemplateLiteral {
     /**
+     * Constraint for schema parts that can appear inside a `TemplateLiteral`.
+     *
+     * **Details**
+     * The schema's encoded value must be a `string`, `number`, or `bigint` so it can
+     * be converted into a template literal string segment.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     interface SchemaPart extends Top {
         readonly Encoded: string | number | bigint;
     }
     /**
+     * Literal value that can be used directly as a part of a `TemplateLiteral`.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type LiteralPart = string | number | bigint;
     /**
+     * A single part of a `TemplateLiteral`, either an interpolated schema part or a
+     * literal `string`, `number`, or `bigint`.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Part = SchemaPart | LiteralPart;
     /**
+     * Ordered list of parts used to construct a `TemplateLiteral` schema.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Parts = ReadonlyArray<Part>;
     type AppendType<Template extends string, Next> = Next extends LiteralPart ? `${Template}${Next}` : Next extends Codec<unknown, infer E extends LiteralPart, unknown, unknown> ? `${Template}${E}` : never;
     /**
-     * @since 4.0.0
+     * Computes the encoded string literal type produced by concatenating the encoded
+     * forms of all template literal parts.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Encoded<Parts> = Parts extends readonly [...infer Init, infer Last] ? AppendType<Encoded<Init>, Last> : ``;
 }
@@ -1435,7 +1545,8 @@ export declare namespace TemplateLiteral {
  * The encoded type is a string formed by concatenating the parts.
  *
  * @see {@link TemplateLiteral} for the constructor function.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface TemplateLiteral<Parts extends TemplateLiteral.Parts> extends Bottom<TemplateLiteral.Encoded<Parts>, TemplateLiteral.Encoded<Parts>, never, never, AST.TemplateLiteral, TemplateLiteral<Parts>> {
     readonly parts: Parts;
@@ -1445,6 +1556,7 @@ export interface TemplateLiteral<Parts extends TemplateLiteral.Parts> extends Bo
  * a literal string/number/bigint or a schema whose encoded type is a string, number, or bigint.
  *
  * **Example** (URL path pattern)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -1453,17 +1565,25 @@ export interface TemplateLiteral<Parts extends TemplateLiteral.Parts> extends Bo
  * ```
  *
  * @see {@link TemplateLiteralParser} for a schema that also parses matched parts into a tuple.
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function TemplateLiteral<const Parts extends TemplateLiteral.Parts>(parts: Parts): TemplateLiteral<Parts>;
 /**
  * Namespace for {@link TemplateLiteralParser} helper types.
  *
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare namespace TemplateLiteralParser {
     /**
-     * @since 4.0.0
+     * Computes the decoded tuple type produced by `TemplateLiteralParser`.
+     *
+     * **Details**
+     * Literal parts contribute their literal value to the tuple. Schema parts
+     * contribute their decoded `Type`.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Type<Parts> = Parts extends readonly [infer Head, ...infer Tail] ? readonly [
         Head extends TemplateLiteral.LiteralPart ? Head : Head extends Codec<infer T, unknown, unknown, unknown> ? T : never,
@@ -1475,7 +1595,8 @@ export declare namespace TemplateLiteralParser {
  * them into a tuple of typed values, one per schema part.
  *
  * @see {@link TemplateLiteralParser} for the constructor function.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> extends Bottom<TemplateLiteralParser.Type<Parts>, TemplateLiteral.Encoded<Parts>, never, never, AST.Arrays, TemplateLiteralParser<Parts>> {
     readonly parts: Parts;
@@ -1485,6 +1606,7 @@ export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> exte
  * one element per schema part.
  *
  * **Example** (Parse path parameters)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -1493,14 +1615,16 @@ export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> exte
  * ```
  *
  * @see {@link TemplateLiteral} for a validation-only version that keeps the string encoded.
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function TemplateLiteralParser<const Parts extends TemplateLiteral.Parts>(parts: Parts): TemplateLiteralParser<Parts>;
 /**
- * Represents a schema derived from a TypeScript `const enum` or a plain enum object,
- * accepting any of its values.
+ * Represents a schema derived from a TypeScript enum object or an enum-like
+ * `as const` object, accepting any of its values.
  *
  * @see {@link Enum} for the constructor function.
+ * @category models
  * @since 4.0.0
  */
 export interface Enum<A extends {
@@ -1512,6 +1636,7 @@ export interface Enum<A extends {
  * Creates a schema from a TypeScript enum object. Validates that the input is one of the enum's values.
  *
  * **Example** (Direction enum)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -1524,6 +1649,7 @@ export interface Enum<A extends {
  * // accepts "Up" or "Down"
  * ```
  *
+ * @category constructors
  * @since 4.0.0
  */
 export declare function Enum<A extends {
@@ -1533,21 +1659,24 @@ export declare function Enum<A extends {
  * Schema for the `never` type. Always fails validation.
  *
  * @see {@link Never} for the schema value.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Never extends Bottom<never, never, never, never, AST.Never, Never> {
 }
 /**
  * Schema for the `never` type. Always fails validation — no value satisfies it.
  *
- * @since 4.0.0
+ * @category schemas
+ * @since 3.10.0
  */
 export declare const Never: Never;
 /**
  * Schema for the `any` type. Accepts any value without validation.
  *
  * @see {@link Any} for the schema value.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Any extends Bottom<any, any, never, never, AST.Any, Any> {
 }
@@ -1555,14 +1684,16 @@ export interface Any extends Bottom<any, any, never, never, AST.Any, Any> {
  * Schema for the `any` type. Accepts any value without validation.
  *
  * @see {@link Unknown} for a safer alternative that uses `unknown`.
- * @since 4.0.0
+ * @category schemas
+ * @since 3.10.0
  */
 export declare const Any: Any;
 /**
  * Schema for the `unknown` type. Accepts any value without validation.
  *
  * @see {@link Unknown} for the schema value.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Unknown extends Bottom<unknown, unknown, never, never, AST.Unknown, Unknown> {
 }
@@ -1570,14 +1701,16 @@ export interface Unknown extends Bottom<unknown, unknown, never, never, AST.Unkn
  * Schema for the `unknown` type. Accepts any value without validation.
  *
  * @see {@link Any} for the `any` variant.
- * @since 4.0.0
+ * @category schemas
+ * @since 3.10.0
  */
 export declare const Unknown: Unknown;
 /**
  * Schema for the `null` literal. Validates that the input is strictly `null`.
  *
  * @see {@link Null} for the schema value.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Null extends Bottom<null, null, never, never, AST.Null, Null> {
 }
@@ -1585,14 +1718,16 @@ export interface Null extends Bottom<null, null, never, never, AST.Null, Null> {
  * Schema for the `null` literal. Validates that the input is strictly `null`.
  *
  * @see {@link NullOr} for a union with another schema.
- * @since 4.0.0
+ * @category schemas
+ * @since 3.10.0
  */
 export declare const Null: Null;
 /**
  * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.
  *
  * @see {@link Undefined} for the schema value.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Undefined extends Bottom<undefined, undefined, never, never, AST.Undefined, Undefined> {
 }
@@ -1600,13 +1735,15 @@ export interface Undefined extends Bottom<undefined, undefined, never, never, AS
  * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.
  *
  * @see {@link UndefinedOr} for a union with another schema.
- * @since 4.0.0
+ * @category schemas
+ * @since 3.10.0
  */
 export declare const Undefined: Undefined;
 /**
  * Schema for `string` values.
  *
  * @see {@link String} for the schema value.
+ * @category models
  * @since 4.0.0
  */
 export interface String extends Bottom<string, string, never, never, AST.String, String> {
@@ -1614,6 +1751,7 @@ export interface String extends Bottom<string, string, never, never, AST.String,
 /**
  * Schema for `string` values. Validates that the input is `typeof` `"string"`.
  *
+ * @category schemas
  * @since 4.0.0
  */
 export declare const String: String;
@@ -1621,6 +1759,7 @@ export declare const String: String;
  * Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.
  *
  * @see {@link Number} for the schema value.
+ * @category models
  * @since 4.0.0
  */
 export interface Number extends Bottom<number, number, never, never, AST.Number, Number> {
@@ -1634,6 +1773,7 @@ export interface Number extends Bottom<number, number, never, never, AST.Number,
  * - Non-finite values are serialized as strings (`"NaN"`, `"Infinity"`, `"-Infinity"`).
  *
  * @see {@link Finite} for a schema that excludes non-finite values.
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Number: Number;
@@ -1641,6 +1781,7 @@ export declare const Number: Number;
  * Schema for `boolean` values.
  *
  * @see {@link Boolean} for the schema value.
+ * @category models
  * @since 4.0.0
  */
 export interface Boolean extends Bottom<boolean, boolean, never, never, AST.Boolean, Boolean> {
@@ -1656,6 +1797,7 @@ export declare const Boolean: Boolean;
  * Schema for `symbol` values.
  *
  * @see {@link Symbol} for the schema value.
+ * @category models
  * @since 4.0.0
  */
 export interface Symbol extends Bottom<symbol, symbol, never, never, AST.Symbol, Symbol> {
@@ -1664,6 +1806,7 @@ export interface Symbol extends Bottom<symbol, symbol, never, never, AST.Symbol,
  * Schema for `symbol` values. Validates that the input is `typeof` `"symbol"`.
  *
  * @see {@link UniqueSymbol} for a schema that matches a specific symbol.
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Symbol: Symbol;
@@ -1671,6 +1814,7 @@ export declare const Symbol: Symbol;
  * Schema for `bigint` values.
  *
  * @see {@link BigInt} for the schema value.
+ * @category models
  * @since 4.0.0
  */
 export interface BigInt extends Bottom<bigint, bigint, never, never, AST.BigInt, BigInt> {
@@ -1678,6 +1822,7 @@ export interface BigInt extends Bottom<bigint, bigint, never, never, AST.BigInt,
 /**
  * Schema for `bigint` values. Validates that the input is `typeof` `"bigint"`.
  *
+ * @category schemas
  * @since 4.0.0
  */
 export declare const BigInt: BigInt;
@@ -1685,20 +1830,23 @@ export declare const BigInt: BigInt;
  * Schema for the `void` type.
  *
  * @see {@link Void} for the schema value.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Void extends Bottom<void, void, never, never, AST.Void, Void> {
 }
 /**
  * Schema for the `void` type. Accepts `undefined` as the encoded value.
  *
- * @since 4.0.0
+ * @category schemas
+ * @since 3.10.0
  */
 export declare const Void: Void;
 /**
  * Schema for the `object` type keyword.
  *
  * @see {@link ObjectKeyword} for the schema value.
+ * @category models
  * @since 4.0.0
  */
 export interface ObjectKeyword extends Bottom<object, object, never, never, AST.ObjectKeyword, ObjectKeyword> {
@@ -1707,6 +1855,7 @@ export interface ObjectKeyword extends Bottom<object, object, never, never, AST.
  * Schema for the `object` type. Validates that the input is a non-null object or function
  * (i.e. `typeof value === "object" && value !== null || typeof value === "function"`).
  *
+ * @category schemas
  * @since 4.0.0
  */
 export declare const ObjectKeyword: ObjectKeyword;
@@ -1714,6 +1863,7 @@ export declare const ObjectKeyword: ObjectKeyword;
  * Represents a schema for a specific unique symbol.
  *
  * @see {@link UniqueSymbol} for the constructor function.
+ * @category models
  * @since 4.0.0
  */
 export interface UniqueSymbol<sym extends symbol> extends Bottom<sym, sym, never, never, AST.UniqueSymbol, UniqueSymbol<sym>> {
@@ -1722,6 +1872,7 @@ export interface UniqueSymbol<sym extends symbol> extends Bottom<sym, sym, never
  * Creates a schema for a specific symbol. Only that exact symbol satisfies the schema.
  *
  * **Example** (Specific symbol)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -1730,6 +1881,7 @@ export interface UniqueSymbol<sym extends symbol> extends Bottom<sym, sym, never
  * ```
  *
  * @see {@link Symbol} for a schema that accepts any symbol.
+ * @category constructors
  * @since 4.0.0
  */
 export declare function UniqueSymbol<const sym extends symbol>(symbol: sym): UniqueSymbol<sym>;
@@ -1746,13 +1898,14 @@ export declare function UniqueSymbol<const sym extends symbol>(symbol: sym): Uni
  * - `Struct.MakeIn<F>` — constructor input (optional/defaulted fields may be omitted)
  * - `Struct.DecodingServices<F>` / `Struct.EncodingServices<F>` — required services
  *
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare namespace Struct {
     /**
      * Constraint for a struct field map: an object whose values are schemas.
      *
-     * @since 4.0.0
+     * @category utility types
+     * @since 3.10.0
      */
     type Fields = {
         readonly [x: PropertyKey]: Top;
@@ -1777,7 +1930,14 @@ export declare namespace Struct {
         -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Type"];
     };
     /**
-     * @since 4.0.0
+     * Computes the decoded object type for a struct field map.
+     *
+     * **Details**
+     * Field schemas contribute their decoded `Type`. `optionalKey` and `optional`
+     * produce optional properties, while `mutableKey` produces writable properties.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Type<F extends Fields> = Simplify<Type_<F>>;
     type Iso_<F extends Fields, O extends keyof F = TypeOptionalKeys<F>, M extends keyof F = TypeMutableKeys<F>> = {
@@ -1790,6 +1950,14 @@ export declare namespace Struct {
         -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Iso"];
     };
     /**
+     * Computes the iso object type for a struct field map from each field schema's
+     * `Iso` type.
+     *
+     * **Details**
+     * The resulting property optionality and mutability follow the same field
+     * modifiers used by `Struct.Type`.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Iso<F extends Fields> = Simplify<Iso_<F>>;
@@ -1813,16 +1981,32 @@ export declare namespace Struct {
         -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Encoded"];
     };
     /**
-     * @since 4.0.0
+     * Computes the encoded object type for a struct field map.
+     *
+     * **Details**
+     * Field schemas contribute their `Encoded` type. Encoded-side optionality and
+     * mutability modifiers determine whether properties are optional or writable in
+     * the encoded shape.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Encoded<F extends Fields> = Simplify<Encoded_<F>>;
     /**
+     * Union of all decoding service requirements needed by the schemas in a struct
+     * field map.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type DecodingServices<F extends Fields> = {
         readonly [K in keyof F]: F[K]["DecodingServices"];
     }[keyof F];
     /**
+     * Union of all encoding service requirements needed by the schemas in a struct
+     * field map.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type EncodingServices<F extends Fields> = {
@@ -1839,12 +2023,27 @@ export declare namespace Struct {
         readonly [K in keyof F as K extends O ? K : never]?: F[K]["~type.make"];
     };
     /**
+     * Computes the input object type accepted when constructing a struct value.
+     *
+     * **Details**
+     * Required fields use each field schema's `~type.make` input. Fields marked
+     * optional or with a constructor default may be omitted.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type MakeIn<F extends Fields> = Simplify<MakeIn_<F>>;
 }
 /**
- * @since 4.0.0
+ * Schema type returned by `Schema.Struct` for an object with a fixed set of
+ * schema-defined fields.
+ *
+ * **Details**
+ * The `fields` property exposes the original field map for reuse, and
+ * `mapFields` creates a new struct schema by transforming that field map.
+ *
+ * @category models
+ * @since 3.10.0
  */
 export interface Struct<Fields extends Struct.Fields> extends Bottom<Struct.Type<Fields>, Struct.Encoded<Fields>, Struct.DecodingServices<Fields>, Struct.EncodingServices<Fields>, AST.Objects, Struct<Fields>, Struct.MakeIn<Fields>, Struct.Iso<Fields>> {
     /**
@@ -1915,8 +2114,8 @@ export interface Struct<Fields extends Struct.Fields> extends Bottom<Struct.Type
  * // { name: 'Alice', age: 30 }
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function Struct<const Fields extends Struct.Fields>(fields: Fields): Struct<Fields>;
 interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
@@ -1939,6 +2138,7 @@ interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
  * ]).mapMembers(Tuple.map(Schema.fieldsAssign({ c: Schema.Number })))
  * ```
  *
+ * @category combinators
  * @since 4.0.0
  */
 export declare function fieldsAssign<const NewFields extends Struct.Fields>(fields: NewFields): fieldsAssign<NewFields>;
@@ -1946,6 +2146,7 @@ export declare function fieldsAssign<const NewFields extends Struct.Fields>(fiel
  * Schema type for a struct with renamed encoded keys. Produced by
  * {@link encodeKeys}.
  *
+ * @category transforming
  * @since 4.0.0
  */
 export interface encodeKeys<S extends Top & {
@@ -1977,7 +2178,7 @@ export interface encodeKeys<S extends Top & {
  * // { name: 'Alice', age: 30 }
  * ```
  *
- * @category Struct transformations
+ * @category transforming
  * @since 4.0.0
  */
 export declare function encodeKeys<S extends Top & {
@@ -2011,8 +2212,8 @@ export declare function encodeKeys<S extends Top & {
  * // Alice Smith
  * ```
  *
+ * @category transforming
  * @since 4.0.0
- * @experimental
  */
 export declare function extendTo<S extends Struct<Struct.Fields>, const Fields extends Struct.Fields>(
 /** The new fields to add */
@@ -2028,10 +2229,17 @@ derive: {
  * - `Record.Type<K, V>` — decoded type of the record
  * - `Record.Encoded<K, V>` — encoded type of the record
  *
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare namespace Record {
     /**
+     * Constraint for schemas that can be used as record keys.
+     *
+     * **Details**
+     * The key schema must decode and encode property keys (`string`, `number`, or
+     * `symbol`) so it can describe object property names.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     interface Key extends Codec<PropertyKey, PropertyKey, unknown, unknown> {
@@ -2039,7 +2247,16 @@ export declare namespace Record {
         readonly "Iso": PropertyKey;
     }
     /**
-     * @since 4.0.0
+     * Computes the decoded object type for a record schema from its key and value
+     * schemas.
+     *
+     * **Details**
+     * The key schema supplies the property keys and the value schema supplies each
+     * property's decoded `Type`. Optional and mutable value schemas affect the
+     * resulting property optionality and writability.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Type<Key extends Record.Key, Value extends Top> = Value extends {
         readonly "~type.optionality": "optional";
@@ -2057,6 +2274,10 @@ export declare namespace Record {
         readonly [P in Key["Type"]]: Value["Type"];
     };
     /**
+     * Computes the iso object type for a record schema from the key schema's `Iso`
+     * keys and the value schema's `Iso` values.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Iso<Key extends Record.Key, Value extends Top> = Value extends {
@@ -2075,7 +2296,15 @@ export declare namespace Record {
         readonly [P in Key["Iso"]]: Value["Iso"];
     };
     /**
-     * @since 4.0.0
+     * Computes the encoded object type for a record schema from the key and value
+     * schemas' encoded types.
+     *
+     * **Details**
+     * Encoded-side optionality and mutability on the value schema determine whether
+     * the encoded record properties are optional or writable.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Encoded<Key extends Record.Key, Value extends Top> = Value extends {
         readonly "~encoded.optionality": "optional";
@@ -2093,14 +2322,30 @@ export declare namespace Record {
         readonly [P in Key["Encoded"]]: Value["Encoded"];
     };
     /**
+     * Union of the decoding service requirements of a record's key schema and value
+     * schema.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type DecodingServices<Key extends Record.Key, Value extends Top> = Key["DecodingServices"] | Value["DecodingServices"];
     /**
+     * Union of the encoding service requirements of a record's key schema and value
+     * schema.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type EncodingServices<Key extends Record.Key, Value extends Top> = Key["EncodingServices"] | Value["EncodingServices"];
     /**
+     * Computes the input object type accepted when constructing a record value.
+     *
+     * **Details**
+     * Keys use the key schema's `~type.make` type and values use the value schema's
+     * `~type.make` type. Value optionality and mutability determine whether
+     * properties are optional or writable.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type MakeIn<Key extends Record.Key, Value extends Top> = Value extends {
@@ -2123,6 +2368,7 @@ export declare namespace Record {
  * Companion type for a key-value record (map) with a typed key and value schema.
  * Produced by {@link Record}.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface $Record<Key extends Record.Key, Value extends Top> extends Bottom<Record.Type<Key, Value>, Record.Encoded<Key, Value>, Record.DecodingServices<Key, Value>, Record.EncodingServices<Key, Value>, AST.Objects, $Record<Key, Value>, Simplify<Record.MakeIn<Key, Value>>, Record.Iso<Key, Value>> {
@@ -2147,8 +2393,8 @@ export interface $Record<Key extends Record.Key, Value extends Top> extends Bott
  * // { a: 1, b: 2 }
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function Record<Key extends Record.Key, Value extends Top>(key: Key, value: Value, options?: {
     readonly keyValueCombiner: {
@@ -2166,47 +2412,80 @@ export declare function Record<Key extends Record.Key, Value extends Top>(key: K
  */
 export declare namespace StructWithRest {
     /**
+     * Constraint for object-like schemas that can be used as the fixed portion of a
+     * `StructWithRest` schema.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Objects = Top & {
         readonly ast: AST.Objects;
     };
     /**
-     * @since 4.0.0
+     * Readonly list of record schemas that provide the additional index signatures
+     * for a `StructWithRest` schema.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Records = ReadonlyArray<$Record<Record.Key, Top>>;
     type MergeTuple<T extends ReadonlyArray<unknown>> = T extends readonly [infer Head, ...infer Tail] ? Head & MergeTuple<Tail> : {};
     /**
-     * @since 4.0.0
+     * Computes the decoded type for `StructWithRest` by intersecting the base object
+     * schema's decoded `Type` with the decoded types of all rest record schemas.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Type<S extends Objects, Records extends StructWithRest.Records> = S["Type"] & MergeTuple<{
         readonly [K in keyof Records]: Records[K]["Type"];
     }>;
     /**
+     * Computes the iso type for `StructWithRest` by intersecting the base object
+     * schema's `Iso` type with the `Iso` types of all rest record schemas.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Iso<S extends Objects, Records extends StructWithRest.Records> = S["Iso"] & MergeTuple<{
         readonly [K in keyof Records]: Records[K]["Iso"];
     }>;
     /**
-     * @since 4.0.0
+     * Computes the encoded type for `StructWithRest` by intersecting the base object
+     * schema's encoded type with the encoded types of all rest record schemas.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Encoded<S extends Objects, Records extends StructWithRest.Records> = S["Encoded"] & MergeTuple<{
         readonly [K in keyof Records]: Records[K]["Encoded"];
     }>;
     /**
+     * Union of the decoding service requirements of the base object schema and all
+     * rest record schemas.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type DecodingServices<S extends Objects, Records extends StructWithRest.Records> = S["DecodingServices"] | {
         [K in keyof Records]: Records[K]["DecodingServices"];
     }[number];
     /**
+     * Union of the encoding service requirements of the base object schema and all
+     * rest record schemas.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type EncodingServices<S extends Objects, Records extends StructWithRest.Records> = S["EncodingServices"] | {
         [K in keyof Records]: Records[K]["EncodingServices"];
     }[number];
     /**
+     * Computes the input type accepted when constructing a `StructWithRest` value by
+     * intersecting the base object's make input with the make inputs of all rest
+     * record schemas.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type MakeIn<S extends Objects, Records extends StructWithRest.Records> = S["~type.make"] & MergeTuple<{
@@ -2217,6 +2496,7 @@ export declare namespace StructWithRest {
  * Companion type for a struct combined with one or more record schemas. Produced
  * by {@link StructWithRest}.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface StructWithRest<S extends StructWithRest.Objects, Records extends StructWithRest.Records> extends Bottom<Simplify<StructWithRest.Type<S, Records>>, Simplify<StructWithRest.Encoded<S, Records>>, StructWithRest.DecodingServices<S, Records>, StructWithRest.EncodingServices<S, Records>, AST.Objects, StructWithRest<S, Records>, Simplify<StructWithRest.MakeIn<S, Records>>, Simplify<StructWithRest.Iso<S, Records>>> {
@@ -2241,7 +2521,7 @@ export interface StructWithRest<S extends StructWithRest.Objects, Records extend
  * type T = typeof schema.Type
  * ```
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare function StructWithRest<const S extends StructWithRest.Objects, const Records extends StructWithRest.Records>(schema: S, records: Records): StructWithRest<S, Records>;
@@ -2253,11 +2533,15 @@ export declare function StructWithRest<const S extends StructWithRest.Objects, c
  * - `Tuple.Encoded<E>` — encoded tuple type
  * - `Tuple.MakeIn<E>` — constructor input tuple
  *
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare namespace Tuple {
     /**
-     * @since 4.0.0
+     * Constraint for the readonly array of element schemas used to define a
+     * fixed-length `Tuple` schema.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Elements = ReadonlyArray<Top>;
     type Type_<Elements, Out extends ReadonlyArray<any> = readonly []> = Elements extends readonly [infer Head, ...infer Tail] ? Head extends {
@@ -2266,7 +2550,14 @@ export declare namespace Tuple {
         readonly "~type.optionality": "optional";
     } ? Type_<Tail, readonly [...Out, T?]> : Type_<Tail, readonly [...Out, T]> : Out : Out;
     /**
-     * @since 4.0.0
+     * Computes the decoded tuple type for a tuple element schema array.
+     *
+     * **Details**
+     * Each element contributes its decoded `Type`; optional element schemas produce
+     * optional tuple positions.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Type<E extends Elements> = Type_<E>;
     type Iso_<Elements, Out extends ReadonlyArray<any> = readonly []> = Elements extends readonly [infer Head, ...infer Tail] ? Head extends {
@@ -2275,6 +2566,10 @@ export declare namespace Tuple {
         readonly "~type.optionality": "optional";
     } ? Iso_<Tail, readonly [...Out, T?]> : Iso_<Tail, readonly [...Out, T]> : Out : Out;
     /**
+     * Computes the iso tuple type for a tuple element schema array from each
+     * element schema's `Iso` type.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Iso<E extends Elements> = Iso_<E>;
@@ -2284,14 +2579,29 @@ export declare namespace Tuple {
         readonly "~encoded.optionality": "optional";
     } ? Encoded_<Tail, readonly [...Out, T?]> : Encoded_<Tail, readonly [...Out, T]> : Out : Out;
     /**
-     * @since 4.0.0
+     * Computes the encoded tuple type for a tuple element schema array.
+     *
+     * **Details**
+     * Each element contributes its `Encoded` type; encoded-side optional element
+     * schemas produce optional tuple positions.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Encoded<E extends Elements> = Encoded_<E>;
     /**
+     * Union of all decoding service requirements needed by the tuple element
+     * schemas.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type DecodingServices<E extends Elements> = E[number]["DecodingServices"];
     /**
+     * Union of all encoding service requirements needed by the tuple element
+     * schemas.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type EncodingServices<E extends Elements> = E[number]["EncodingServices"];
@@ -2303,6 +2613,13 @@ export declare namespace Tuple {
         readonly "~type.constructor.default": "with-default";
     } ? MakeIn_<Tail, readonly [...Out, T?]> : MakeIn_<Tail, readonly [...Out, T]> : Out : Out;
     /**
+     * Computes the input tuple type accepted when constructing a tuple value.
+     *
+     * **Details**
+     * Each element uses its `~type.make` input type. Optional elements and elements
+     * with constructor defaults produce optional tuple positions.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type MakeIn<E extends Elements> = MakeIn_<E>;
@@ -2310,7 +2627,8 @@ export declare namespace Tuple {
 /**
  * Companion type for a fixed-length tuple. Produced by {@link Tuple}.
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Tuple<Elements extends Tuple.Elements> extends Bottom<Tuple.Type<Elements>, Tuple.Encoded<Elements>, Tuple.DecodingServices<Elements>, Tuple.EncodingServices<Elements>, AST.Arrays, Tuple<Elements>, Tuple.MakeIn<Elements>, Tuple.Iso<Elements>> {
     readonly elements: Elements;
@@ -2347,8 +2665,8 @@ export interface Tuple<Elements extends Tuple.Elements> extends Bottom<Tuple.Typ
  * // [ 'hello', 42 ]
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function Tuple<const Elements extends ReadonlyArray<Top>>(elements: Elements): Tuple<Elements>;
 /**
@@ -2363,7 +2681,11 @@ export declare function Tuple<const Elements extends ReadonlyArray<Top>>(element
  */
 export declare namespace TupleWithRest {
     /**
-     * @since 4.0.0
+     * Constraint for tuple-like schemas that can be used as the fixed leading
+     * portion of a `TupleWithRest` schema.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type TupleType = Top & {
         readonly Type: ReadonlyArray<unknown>;
@@ -2373,11 +2695,26 @@ export declare namespace TupleWithRest {
         readonly "Iso": ReadonlyArray<unknown>;
     };
     /**
-     * @since 4.0.0
+     * Non-empty list of schemas used for the rest portion of a `TupleWithRest`.
+     *
+     * **Details**
+     * The first schema describes the repeated rest element. Additional schemas, when
+     * present, describe trailing tuple elements after the repeated rest segment.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Rest = readonly [Top, ...Array<Top>];
     /**
-     * @since 4.0.0
+     * Computes the decoded tuple type for a `TupleWithRest`.
+     *
+     * **Details**
+     * The output starts with the fixed tuple elements, continues with zero or more
+     * values decoded by the first rest schema, and includes any trailing rest schemas
+     * as fixed tuple positions.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Type<T extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Top, ...infer Tail extends ReadonlyArray<Top>] ? Readonly<[
         ...T,
@@ -2387,6 +2724,14 @@ export declare namespace TupleWithRest {
         }
     ]> : T;
     /**
+     * Computes the iso tuple type for a `TupleWithRest`.
+     *
+     * **Details**
+     * The output starts with the fixed tuple's `Iso` elements, continues with zero
+     * or more values using the first rest schema's `Iso`, and includes any trailing
+     * rest schemas as fixed tuple positions.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Iso<T extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Top, ...infer Tail extends ReadonlyArray<Top>] ? Readonly<[
@@ -2397,7 +2742,15 @@ export declare namespace TupleWithRest {
         }
     ]> : T;
     /**
-     * @since 4.0.0
+     * Computes the encoded tuple type for `TupleWithRest`.
+     *
+     * **Details**
+     * The leading tuple's encoded elements are kept first. The encoded type of the
+     * first rest schema may repeat zero or more times, and the encoded types of any
+     * additional rest schemas become required trailing tuple elements.
+     *
+     * @category utility types
+     * @since 3.10.0
      */
     type Encoded<E extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Top, ...infer Tail extends ReadonlyArray<Top>] ? readonly [
         ...E,
@@ -2407,6 +2760,14 @@ export declare namespace TupleWithRest {
         }
     ] : E;
     /**
+     * Computes the constructor input tuple type for `TupleWithRest`.
+     *
+     * **Details**
+     * The leading tuple's make input elements are kept first. The make input type of
+     * the first rest schema may repeat zero or more times, and the make input types
+     * of any additional rest schemas become required trailing tuple elements.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type MakeIn<M extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Top, ...infer Tail extends ReadonlyArray<Top>] ? readonly [
@@ -2421,6 +2782,7 @@ export declare namespace TupleWithRest {
  * Companion type for a tuple with additional rest elements. Produced by
  * {@link TupleWithRest}.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends TupleWithRest.Rest> extends Bottom<TupleWithRest.Type<S["Type"], Rest>, TupleWithRest.Encoded<S["Encoded"], Rest>, S["DecodingServices"] | Rest[number]["DecodingServices"], S["EncodingServices"] | Rest[number]["EncodingServices"], AST.Arrays, TupleWithRest<S, Rest>, TupleWithRest.MakeIn<S["~type.make"], Rest>, TupleWithRest.Iso<S["Iso"], Rest>> {
@@ -2428,9 +2790,14 @@ export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends T
     readonly rest: Rest;
 }
 /**
- * Extends a fixed-length tuple schema with rest elements, creating a variadic
- * tuple that starts with the fixed elements and ends with zero or more rest
- * elements.
+ * Extends a fixed-length tuple schema with a variadic rest segment.
+ *
+ * **Details**
+ * The resulting tuple starts with the fixed elements from `schema`. The first
+ * schema in `rest` is the repeatable element schema, and any additional schemas
+ * in `rest` are required trailing tuple elements after the variadic segment. For
+ * example, `[Schema.Boolean, Schema.String]` represents zero or more booleans
+ * followed by a final string.
  *
  * **Example** (Tuple with rest)
  *
@@ -2448,13 +2815,19 @@ export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends T
  * // [ 'hello', 1, true, false ]
  * ```
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare function TupleWithRest<S extends Tuple<Tuple.Elements>, const Rest extends TupleWithRest.Rest>(schema: S, rest: Rest): TupleWithRest<S, Rest>;
 /**
- * Companion type for a `ReadonlyArray`. Produced by {@link ArraySchema}.
+ * Schema interface produced by `Schema.Array` for readonly arrays.
+ *
+ * **Details**
+ * The decoded type is `ReadonlyArray<S["Type"]>`, the encoded type is
+ * `ReadonlyArray<S["Encoded"]>`, and the element schema is available as
+ * `schema`.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface $Array<S extends Top> extends Bottom<ReadonlyArray<S["Type"]>, ReadonlyArray<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"], AST.Arrays, $Array<S>, ReadonlyArray<S["~type.make"]>, ReadonlyArray<S["Iso"]>> {
@@ -2465,7 +2838,7 @@ interface ArrayLambda extends Lambda {
     readonly "~lambda.out": this["~lambda.in"] extends Top ? $Array<this["~lambda.in"]> : never;
 }
 /**
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 declare const ArraySchema: ArrayLambda;
@@ -2485,14 +2858,15 @@ export {
  * // [ 'a', 'b', 'c' ]
  * ```
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 ArraySchema as Array };
 /**
  * Companion type for a non-empty `ReadonlyArray`. Produced by {@link NonEmptyArray}.
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface NonEmptyArray<S extends Top> extends Bottom<readonly [S["Type"], ...Array<S["Type"]>], readonly [S["Encoded"], ...Array<S["Encoded"]>], S["DecodingServices"], S["EncodingServices"], AST.Arrays, NonEmptyArray<S>, readonly [S["~type.make"], ...Array<S["~type.make"]>], readonly [S["Iso"], ...Array<S["Iso"]>]> {
     readonly schema: S;
@@ -2516,35 +2890,44 @@ interface NonEmptyArrayLambda extends Lambda {
  * Schema.decodeUnknownSync(schema)([])          // throws
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const NonEmptyArray: NonEmptyArrayLambda;
 /**
+ * Schema interface returned by `ArrayEnsure`, which normalizes a single item or
+ * an array of items into a readonly array.
+ *
+ * **Details**
+ * The schema decodes from `S` or `Schema.Array(S)` and produces
+ * `ReadonlyArray<S["Type"]>`.
+ *
  * @category Arrays
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface ArrayEnsure<S extends Top> extends decodeTo<$Array<toType<S>>, Union<readonly [S, $Array<S>]>> {
     readonly "Rebuild": ArrayEnsure<S>;
 }
 /**
- * Decodes a single value or an array of values into an array.
+ * Creates a schema that accepts either a value decoded by `schema` or an array
+ * decoded by `Schema.Array(schema)`, then returns an array.
  *
- * Decoding:
- * - a single value is decoded as a one-element array
- * - an array is decoded as-is
+ * **Details**
+ * The single-value branch is tried before the array branch. If `schema` itself
+ * accepts arrays, an array input can be treated as one value and wrapped in a
+ * one-element array.
  *
- * Encoding:
- * - a one-element array is encoded as a single value
- * - arrays with more than one element are encoded as arrays
+ * During encoding, one-element arrays are encoded as the single element. Empty
+ * arrays and arrays with two or more elements are encoded as arrays.
  *
  * @category Arrays
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function ArrayEnsure<S extends Top>(schema: S): ArrayEnsure<S>;
 /**
  * Companion type for an array with unique elements. Produced by {@link UniqueArray}.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface UniqueArray<S extends Top> extends $Array<S> {
@@ -2556,7 +2939,7 @@ export interface UniqueArray<S extends Top> extends $Array<S> {
  * The equivalence used to determine uniqueness is the one provided by
  * `Schema.toEquivalence(item)`.
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare function UniqueArray<S extends Top>(item: S): UniqueArray<S>;
@@ -2564,7 +2947,8 @@ export declare function UniqueArray<S extends Top>(item: S): UniqueArray<S>;
  * Schema type that makes array or tuple elements mutable (removes `readonly`).
  * Produced by {@link mutable}.
  *
- * @since 4.0.0
+ * @category transforming
+ * @since 3.10.0
  */
 export interface mutable<S extends Top & {
     readonly "ast": AST.Arrays;
@@ -2593,13 +2977,15 @@ interface mutableLambda extends Lambda {
  * type T = typeof schema.Type
  * ```
  *
- * @since 4.0.0
+ * @category transforming
+ * @since 3.10.0
  */
 export declare const mutable: mutableLambda;
 /**
  * Companion type for a union of multiple schemas. Produced by {@link Union}.
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Union<Members extends ReadonlyArray<Top>> extends Bottom<{
     [K in keyof Members]: Members[K]["Type"];
@@ -2654,8 +3040,8 @@ export interface Union<Members extends ReadonlyArray<Top>> extends Bottom<{
  * Schema.decodeUnknownSync(schema)(42)       // 42
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function Union<const Members extends ReadonlyArray<Top>>(members: Members, options?: {
     mode?: "anyOf" | "oneOf";
@@ -2664,6 +3050,7 @@ export declare function Union<const Members extends ReadonlyArray<Top>>(members:
  * Represents a union schema of multiple literal values.
  *
  * @see {@link Literals} for the constructor function.
+ * @category models
  * @since 4.0.0
  */
 export interface Literals<L extends ReadonlyArray<AST.LiteralValue>> extends Bottom<L[number], L[number], never, never, AST.Union<AST.Literal>, Literals<L>> {
@@ -2686,6 +3073,7 @@ export interface Literals<L extends ReadonlyArray<AST.LiteralValue>> extends Bot
  * Creates a union schema from an array of literal values.
  *
  * **Example** (Status codes)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -2694,14 +3082,15 @@ export interface Literals<L extends ReadonlyArray<AST.LiteralValue>> extends Bot
  * ```
  *
  * @see {@link Literal} for a schema that represents a single literal.
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare function Literals<const L extends ReadonlyArray<AST.LiteralValue>>(literals: L): Literals<L>;
 /**
  * Companion type for `S | null`. Produced by {@link NullOr}.
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface NullOr<S extends Top> extends Union<readonly [S, Null]> {
     readonly "Rebuild": NullOr<S>;
@@ -2713,14 +3102,15 @@ interface NullOrLambda extends Lambda {
 /**
  * Creates a union schema of `S | null`.
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const NullOr: NullOrLambda;
 /**
  * Companion type for `S | undefined`. Produced by {@link UndefinedOr}.
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface UndefinedOr<S extends Top> extends Union<readonly [S, Undefined]> {
     readonly "Rebuild": UndefinedOr<S>;
@@ -2732,13 +3122,14 @@ interface UndefinedOrLambda extends Lambda {
 /**
  * Creates a union schema of `S | undefined`.
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const UndefinedOr: UndefinedOrLambda;
 /**
  * Companion type for `S | null | undefined`. Produced by {@link NullishOr}.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface NullishOr<S extends Top> extends Union<readonly [S, Null, Undefined]> {
     readonly "Rebuild": NullishOr<S>;
@@ -2749,13 +3140,14 @@ interface NullishOrLambda extends Lambda {
 }
 /**
  * Creates a union schema of `S | null | undefined`.
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const NullishOr: NullishOrLambda;
 /**
  * Schema type wrapping a lazily-evaluated schema. Produced by {@link suspend}.
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface suspend<S extends Top> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], AST.Suspend, suspend<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
 }
@@ -2765,6 +3157,7 @@ export interface suspend<S extends Top> extends Bottom<S["Type"], S["Encoded"],
  * preventing infinite recursion during schema definition.
  *
  * **Example** (Recursive tree schema)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -2779,8 +3172,8 @@ export interface suspend<S extends Top> extends Bottom<S["Type"], S["Encoded"],
  * })
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function suspend<S extends Top>(f: () => S): suspend<S>;
 /**
@@ -2788,6 +3181,7 @@ export declare function suspend<S extends Top>(f: () => S): suspend<S>;
  * changing the TypeScript type.
  *
  * **Example** (Adding checks to a schema)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -2796,7 +3190,7 @@ export declare function suspend<S extends Top>(f: () => S): suspend<S>;
  * )
  * ```
  *
- * @category Filtering
+ * @category filtering
  * @since 4.0.0
  */
 export declare function check<S extends Top>(...checks: readonly [AST.Check<S["Type"]>, ...Array<AST.Check<S["Type"]>>]): (self: S) => S["Rebuild"];
@@ -2804,7 +3198,8 @@ export declare function check<S extends Top>(...checks: readonly [AST.Check<S["T
  * The output type of {@link refine}, narrowing the schema's `Type` to `T` via a
  * type guard.
  *
- * @since 4.0.0
+ * @category filtering
+ * @since 3.10.0
  */
 export interface refine<T extends S["Type"], S extends Top> extends Bottom<T, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], refine<T, S>, S["~type.make.in"], T, S["~type.parameters"], T, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
     readonly schema: S;
@@ -2813,8 +3208,14 @@ export interface refine<T extends S["Type"], S extends Top> extends Bottom<T, S[
  * Narrows the TypeScript type of a schema's output via a type guard predicate,
  * attaching the guard as a runtime filter check.
  *
- * @category Filtering
- * @since 4.0.0
+ * The `annotations` parameter annotates the filter created by the refinement.
+ * With the default formatter, failed refinements use `message` first,
+ * `expected` second, and `<filter>` when neither is provided. `identifier`
+ * names type-level failures before the refinement runs; it does not name the
+ * failed refinement itself.
+ *
+ * @category filtering
+ * @since 3.10.0
  */
 export declare function refine<S extends Top, T extends S["Type"]>(refinement: (value: S["Type"]) => value is T, annotations?: Annotations.Filter): (schema: S) => refine<T, S>;
 type DistributeBrands<B> = UnionToIntersection<B extends infer U extends string ? Brand.Brand<U> : never>;
@@ -2822,7 +3223,8 @@ type DistributeBrands<B> = UnionToIntersection<B extends infer U extends string
  * The output type of {@link brand}, intersecting the schema's `Type` with one or
  * more {@link Brand.Brand} tags.
  *
- * @since 4.0.0
+ * @category branding
+ * @since 3.10.0
  */
 export interface brand<S extends Top, B> extends Bottom<S["Type"] & DistributeBrands<B>, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], brand<S, B>, S["~type.make.in"], S["Type"] & DistributeBrands<B>, S["~type.parameters"], S["Type"] & DistributeBrands<B>, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
     readonly schema: S;
@@ -2832,16 +3234,16 @@ export interface brand<S extends Top, B> extends Bottom<S["Type"] & DistributeBr
  * Adds a nominal brand to a schema, intersecting the output type with
  * `Brand.Brand<B>` to prevent accidental mixing of structurally identical types.
  *
- * @category Branding
- * @since 4.0.0
+ * @category branding
+ * @since 3.10.0
  */
 export declare function brand<B extends string>(identifier: B): <S extends Top>(schema: S) => brand<S["Rebuild"], B>;
 /**
  * Creates a branded schema from a {@link Brand.Constructor}, applying the
  * constructor's checks and brand tag to the underlying schema.
  *
- * @category Branding
- * @since 4.0.0
+ * @category branding
+ * @since 3.10.0
  */
 export declare function fromBrand<A extends Brand.Brand<any>>(identifier: string, ctor: Brand.Constructor<A>): <S extends Top & {
     readonly "Type": Brand.Brand.Unbranded<A>;
@@ -2853,6 +3255,7 @@ export declare function fromBrand<A extends Brand.Brand<any>>(identifier: string
  * or augment it — including adding service requirements via `RD`.
  *
  * @see {@link middlewareDecoding} for the constructor
+ * @category decoding
  * @since 4.0.0
  */
 export interface middlewareDecoding<S extends Top, RD> extends Bottom<S["Type"], S["Encoded"], RD, S["EncodingServices"], S["ast"], middlewareDecoding<S, RD>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -2878,6 +3281,7 @@ export interface middlewareDecoding<S extends Top, RD> extends Bottom<S["Type"],
  * ```
  *
  * @see {@link catchDecoding} for a simpler error-recovery variant
+ * @category decoding
  * @since 4.0.0
  */
 export declare function middlewareDecoding<S extends Top, RD>(decode: (effect: Effect.Effect<Option_.Option<S["Type"]>, Issue.Issue, S["DecodingServices"]>, options: AST.ParseOptions) => Effect.Effect<Option_.Option<S["Type"]>, Issue.Issue, RD>): (schema: S) => middlewareDecoding<S, RD>;
@@ -2888,6 +3292,7 @@ export declare function middlewareDecoding<S extends Top, RD>(decode: (effect: E
  * or augment it — including adding service requirements via `RE`.
  *
  * @see {@link middlewareEncoding} for the constructor
+ * @category encoding
  * @since 4.0.0
  */
 export interface middlewareEncoding<S extends Top, RE> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], RE, S["ast"], middlewareEncoding<S, RE>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -2913,6 +3318,7 @@ export interface middlewareEncoding<S extends Top, RE> extends Bottom<S["Type"],
  * ```
  *
  * @see {@link catchEncoding} for a simpler error-recovery variant
+ * @category encoding
  * @since 4.0.0
  */
 export declare function middlewareEncoding<S extends Top, RE>(encode: (effect: Effect.Effect<Option_.Option<S["Encoded"]>, Issue.Issue, S["EncodingServices"]>, options: AST.ParseOptions) => Effect.Effect<Option_.Option<S["Encoded"]>, Issue.Issue, RE>): (schema: S) => middlewareEncoding<S, RE>;
@@ -2933,12 +3339,14 @@ export declare function middlewareEncoding<S extends Top, RE>(encode: (effect: E
  * ```
  *
  * @see {@link catchDecodingWithContext} to add service requirements to the handler
+ * @category error handling
  * @since 4.0.0
  */
 export declare function catchDecoding<S extends Top>(f: (issue: Issue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, Issue.Issue>): (self: S) => S["Rebuild"];
 /**
  * Like {@link catchDecoding}, but the handler may require Effect services (`R`).
  *
+ * @category error handling
  * @since 4.0.0
  */
 export declare function catchDecodingWithContext<S extends Top, R = never>(f: (issue: Issue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, Issue.Issue, R>): (self: S) => middlewareDecoding<S, S["DecodingServices"] | R>;
@@ -2949,22 +3357,28 @@ export declare function catchDecodingWithContext<S extends Top, R = never>(f: (i
  * succeeds with a fallback value or re-fails with a (possibly different) issue.
  *
  * @see {@link catchEncodingWithContext} to add service requirements to the handler
+ * @category error handling
  * @since 4.0.0
  */
 export declare function catchEncoding<S extends Top>(f: (issue: Issue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, Issue.Issue>): (self: S) => S["Rebuild"];
 /**
  * Like {@link catchEncoding}, but the handler may require Effect services (`R`).
  *
+ * @category error handling
  * @since 4.0.0
  */
 export declare function catchEncodingWithContext<S extends Top, R = never>(f: (issue: Issue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, Issue.Issue, R>): (self: S) => middlewareEncoding<S, S["EncodingServices"] | R>;
 /**
- * The type produced by {@link decodeTo} when a custom transformation is provided.
+ * Schema type produced by `decodeTo` when a custom transformation composes a
+ * `From` schema with a `To` schema.
  *
- * - `Type` is `To["Type"]`, `Encoded` is `From["Encoded"]`
- * - Decoding services from both `from` and `to` are combined
+ * **Details**
+ * `Type` is `To["Type"]` and `Encoded` is `From["Encoded"]`. Decoding services
+ * are `To["DecodingServices"] | From["DecodingServices"] | RD`; encoding
+ * services are `To["EncodingServices"] | From["EncodingServices"] | RE`.
  *
  * @see {@link compose} for the passthrough (no transformation) variant
+ * @category transforming
  * @since 4.0.0
  */
 export interface decodeTo<To extends Top, From extends Top, RD = never, RE = never> extends Bottom<To["Type"], From["Encoded"], To["DecodingServices"] | From["DecodingServices"] | RD, To["EncodingServices"] | From["EncodingServices"] | RE, To["ast"], decodeTo<To, From, RD, RE>, To["~type.make.in"], To["Iso"], To["~type.parameters"], To["~type.make"], To["~type.mutability"], To["~type.optionality"], To["~type.constructor.default"], From["~encoded.mutability"], From["~encoded.optionality"]> {
@@ -2978,7 +3392,8 @@ export interface decodeTo<To extends Top, From extends Top, RD = never, RE = nev
  * are composed using their natural encoding/decoding chain.
  *
  * @see {@link decodeTo} for the transformation variant
- * @since 4.0.0
+ * @category transforming
+ * @since 3.10.0
  */
 export interface compose<To extends Top, From extends Top> extends decodeTo<To, From> {
 }
@@ -3022,6 +3437,7 @@ export interface compose<To extends Top, From extends Top> extends decodeTo<To,
  * // result: 123
  * ```
  *
+ * @category transforming
  * @since 4.0.0
  */
 export declare function decodeTo<To extends Top>(to: To): <From extends Top>(from: From) => compose<To, From>;
@@ -3064,7 +3480,8 @@ export declare function decodeTo<To extends Top, From extends Top, RD = never, R
  * // result: "hello"
  * ```
  *
- * @since 4.0.0
+ * @category transforming
+ * @since 3.10.0
  */
 export declare function decode<S extends Top, RD = never, RE = never>(transformation: {
     readonly decode: Getter.Getter<S["Type"], S["Type"], RD>;
@@ -3090,6 +3507,7 @@ export declare function decode<S extends Top, RD = never, RE = never>(transforma
  * )
  * ```
  *
+ * @category transforming
  * @since 4.0.0
  */
 export declare function encodeTo<To extends Top>(to: To): <From extends Top>(from: From) => decodeTo<From, To>;
@@ -3117,7 +3535,8 @@ export declare function encodeTo<To extends Top, From extends Top, RD = never, R
  * )
  * ```
  *
- * @since 4.0.0
+ * @category transforming
+ * @since 3.10.0
  */
 export declare function encode<S extends Top, RD = never, RE = never>(transformation: {
     readonly decode: Getter.Getter<S["Encoded"], S["Encoded"], RD>;
@@ -3128,16 +3547,25 @@ export declare function encode<S extends Top, RD = never, RE = never>(transforma
  *
  * Only schemas that satisfy this constraint can be passed to {@link withConstructorDefault}.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface WithoutConstructorDefault {
     readonly "~type.constructor.default": "no-default";
 }
 /**
- * The type produced by {@link withConstructorDefault} — a schema with `"~type.constructor.default": "with-default"`.
+ * Schema type returned by `withConstructorDefault` after attaching a default used
+ * by constructor helpers.
+ *
+ * **Details**
+ * The default affects `make` and related constructor helpers only; decoding and
+ * encoding still use the original schema behavior. The schema is marked as
+ * already having a constructor default so another constructor default cannot be
+ * added.
  *
  * @see {@link withConstructorDefault} for the constructor
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export interface withConstructorDefault<S extends Top & WithoutConstructorDefault> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], withConstructorDefault<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], "with-default", S["~encoded.mutability"], S["~encoded.optionality"]> {
     readonly schema: S;
@@ -3164,18 +3592,20 @@ export interface withConstructorDefault<S extends Top & WithoutConstructorDefaul
  * // value: { name: "anonymous" }
  * ```
  *
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
-export declare function withConstructorDefault<S extends Top & WithoutConstructorDefault>(defaultValue: Effect.Effect<S["~type.make.in"]>): (schema: S) => withConstructorDefault<S>;
+export declare function withConstructorDefault<S extends Top & WithoutConstructorDefault>(defaultValue: Effect.Effect<S["~type.make.in"], SchemaError>): (schema: S) => withConstructorDefault<S>;
 /**
  * The type produced by {@link withDecodingDefaultKey}: a schema whose `Encoded`
  * side is `optionalKey` and that fills in a default `Encoded` value during decoding.
  *
  * @see {@link withDecodingDefaultKey} for the constructor
+ * @category decoding
  * @since 4.0.0
  */
-export interface withDecodingDefaultKey<S extends Top> extends decodeTo<S, optionalKey<toEncoded<S>>> {
-    readonly "Rebuild": withDecodingDefaultKey<S>;
+export interface withDecodingDefaultKey<S extends Top, R = never> extends decodeTo<S, optionalKey<toEncoded<S>>, R> {
+    readonly "Rebuild": withDecodingDefaultKey<S, R>;
 }
 /**
  * Options for {@link withDecodingDefaultKey} and {@link withDecodingDefault}.
@@ -3184,6 +3614,7 @@ export interface withDecodingDefaultKey<S extends Top> extends decodeTo<S, optio
  *   - `"passthrough"` (default): pass the value through during encoding
  *   - `"omit"`: omit the key from the encoded output
  *
+ * @category models
  * @since 4.0.0
  */
 export type DecodingDefaultOptions = {
@@ -3218,19 +3649,21 @@ export type DecodingDefaultOptions = {
  *
  * @see {@link withDecodingDefault} for the value-level variant (key absent **or** `undefined`)
  * @see {@link withDecodingDefaultTypeKey} for the variant where the default is a `Type` value
+ * @category decoding
  * @since 4.0.0
  */
-export declare function withDecodingDefaultKey<S extends Top>(defaultValue: Effect.Effect<S["Encoded"]>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultKey<S>;
+export declare function withDecodingDefaultKey<S extends Top, R = never>(defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultKey<S, R>;
 /**
  * The type produced by {@link withDecodingDefaultTypeKey}: a schema whose
  * `Encoded` side is `optionalKey` and that fills in a default `Type` value
  * during decoding.
  *
  * @see {@link withDecodingDefaultTypeKey} for the constructor
+ * @category decoding
  * @since 4.0.0
  */
-export interface withDecodingDefaultTypeKey<S extends Top> extends decodeTo<withDecodingDefaultKey<toType<S>>, optionalKey<S>> {
-    readonly "Rebuild": withDecodingDefaultTypeKey<S>;
+export interface withDecodingDefaultTypeKey<S extends Top, R = never> extends decodeTo<withDecodingDefaultKey<toType<S>, R>, optionalKey<S>> {
+    readonly "Rebuild": withDecodingDefaultTypeKey<S, R>;
 }
 /**
  * Makes a struct key optional on the `Encoded` side (`optionalKey`, so the
@@ -3249,18 +3682,20 @@ export interface withDecodingDefaultTypeKey<S extends Top> extends decodeTo<with
  *
  * @see {@link withDecodingDefaultKey} for the variant where the default is an `Encoded` value
  * @see {@link withDecodingDefaultType} for the value-level variant
+ * @category decoding
  * @since 4.0.0
  */
-export declare function withDecodingDefaultTypeKey<S extends Top>(defaultValue: Effect.Effect<S["Type"]>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultTypeKey<S>;
+export declare function withDecodingDefaultTypeKey<S extends Top, R = never>(defaultValue: Effect.Effect<S["Type"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultTypeKey<S, R>;
 /**
  * The type produced by {@link withDecodingDefault}: a schema whose `Encoded`
  * side is `optional` and that fills in a default `Encoded` value during decoding.
  *
  * @see {@link withDecodingDefault} for the constructor
- * @since 4.0.0
+ * @category decoding
+ * @since 3.10.0
  */
-export interface withDecodingDefault<S extends Top> extends decodeTo<S, optional<toEncoded<S>>> {
-    readonly "Rebuild": withDecodingDefault<S>;
+export interface withDecodingDefault<S extends Top, R = never> extends decodeTo<S, optional<toEncoded<S>>, R> {
+    readonly "Rebuild": withDecodingDefault<S, R>;
 }
 /**
  * Wraps the `Encoded` side with `optional` (key absent **or** `undefined`)
@@ -3291,19 +3726,21 @@ export interface withDecodingDefault<S extends Top> extends decodeTo<S, optional
  *
  * @see {@link withDecodingDefaultKey} for the key-level variant (key absent only, not `undefined`)
  * @see {@link withDecodingDefaultType} for the variant where the default is a `Type` value
- * @since 4.0.0
+ * @category decoding
+ * @since 3.10.0
  */
-export declare function withDecodingDefault<S extends Top>(defaultValue: Effect.Effect<S["Encoded"]>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefault<S>;
+export declare function withDecodingDefault<S extends Top, R = never>(defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefault<S, R>;
 /**
  * The type produced by {@link withDecodingDefaultType}: a schema whose
  * `Encoded` side is `optional` and that fills in a default `Type` value during
  * decoding.
  *
  * @see {@link withDecodingDefaultType} for the constructor
+ * @category decoding
  * @since 4.0.0
  */
-export interface withDecodingDefaultType<S extends Top> extends decodeTo<withDecodingDefault<toType<S>>, optional<S>> {
-    readonly "Rebuild": withDecodingDefaultType<S>;
+export interface withDecodingDefaultType<S extends Top, R = never> extends decodeTo<withDecodingDefault<toType<S>, R>, optional<S>> {
+    readonly "Rebuild": withDecodingDefaultType<S, R>;
 }
 /**
  * Wraps the `Encoded` side with `optional` (key absent **or** `undefined`)
@@ -3322,16 +3759,18 @@ export interface withDecodingDefaultType<S extends Top> extends decodeTo<withDec
  *
  * @see {@link withDecodingDefault} for the variant where the default is an `Encoded` value
  * @see {@link withDecodingDefaultTypeKey} for the key-level variant
+ * @category decoding
  * @since 4.0.0
  */
-export declare function withDecodingDefaultType<S extends Top>(defaultValue: Effect.Effect<S["Type"]>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultType<S>;
+export declare function withDecodingDefaultType<S extends Top, R = never>(defaultValue: Effect.Effect<S["Type"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultType<S, R>;
 /**
  * The type produced by {@link tag} — a literal schema with a constructor default.
  *
  * Used as the type of the `_tag` field in {@link TaggedStruct} and related helpers.
  *
  * @see {@link tag} for the constructor
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export interface tag<Tag extends AST.LiteralValue> extends withConstructorDefault<Literal<Tag>> {
 }
@@ -3354,7 +3793,8 @@ export interface tag<Tag extends AST.LiteralValue> extends withConstructorDefaul
  *
  * @see {@link tagDefaultOmit} to also omit the tag during encoding
  * @see {@link TaggedStruct} for a shorthand that adds `_tag` automatically
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function tag<Tag extends AST.LiteralValue>(literal: Tag): tag<Tag>;
 /**
@@ -3378,14 +3818,16 @@ export declare function tag<Tag extends AST.LiteralValue>(literal: Tag): tag<Tag
  * ```
  *
  * @see {@link tag} for the variant that keeps the tag during encoding
+ * @category constructors
  * @since 4.0.0
  */
-export declare function tagDefaultOmit<Tag extends AST.LiteralValue>(literal: Tag): withDecodingDefaultKey<tag<Tag>>;
+export declare function tagDefaultOmit<Tag extends AST.LiteralValue>(literal: Tag): withDecodingDefaultKey<tag<Tag>, never>;
 /**
  * The type produced by {@link TaggedStruct} — a {@link Struct} with an extra `_tag` field of type {@link tag}.
  *
  * @see {@link TaggedStruct} for the constructor
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export type TaggedStruct<Tag extends AST.LiteralValue, Fields extends Struct.Fields> = Struct<Simplify<{
     readonly _tag: tag<Tag>;
@@ -3429,8 +3871,8 @@ export type TaggedStruct<Tag extends AST.LiteralValue, Fields extends Struct.Fie
  * const literal = tagged.fields._tag.schema.literal
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function TaggedStruct<const Tag extends AST.LiteralValue, const Fields extends Struct.Fields>(value: Tag, fields: Fields): TaggedStruct<Tag, Fields>;
 /**
@@ -3468,8 +3910,8 @@ type TaggedUnionUtils<Tag extends PropertyKey, Members extends ReadonlyArray<Top
  * The type produced by {@link toTaggedUnion} — a {@link Union} augmented with `cases`, `guards`, `isAnyOf`, and `match` utilities.
  *
  * @see {@link toTaggedUnion} for the constructor
+ * @category combinators
  * @since 4.0.0
- * @experimental
  */
 export type toTaggedUnion<Tag extends PropertyKey, Members extends ReadonlyArray<Top & {
     readonly Type: {
@@ -3497,8 +3939,8 @@ export type toTaggedUnion<Tag extends PropertyKey, Members extends ReadonlyArray
  * ```
  *
  * @see {@link TaggedUnion} for a shorthand that builds the union from scratch
+ * @category combinators
  * @since 4.0.0
- * @experimental
  */
 export declare function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag): <const Members extends ReadonlyArray<Top & {
     readonly Type: { readonly [K in Tag]: PropertyKey; };
@@ -3508,8 +3950,8 @@ export declare function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag):
  * Produced by {@link TaggedUnion}.
  *
  * @see {@link TaggedUnion} for the constructor
+ * @category models
  * @since 4.0.0
- * @experimental
  */
 export interface TaggedUnion<Cases extends Record<string, Top>> extends Bottom<{
     [K in keyof Cases]: Cases[K]["Type"];
@@ -3561,7 +4003,7 @@ export interface TaggedUnion<Cases extends Record<string, Top>> extends Bottom<{
  * ```
  *
  * @see {@link toTaggedUnion} to augment an existing union instead
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare function TaggedUnion<const CasesByTag extends Record<string, Struct.Fields>>(casesByTag: CasesByTag): TaggedUnion<{
@@ -3573,6 +4015,7 @@ export declare function TaggedUnion<const CasesByTag extends Record<string, Stru
  * making the decoded value nominally distinct.
  *
  * @see {@link Opaque} for the constructor
+ * @category models
  * @since 4.0.0
  */
 export interface Opaque<Self, S extends Top, Brand> extends Bottom<Self, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], S["Rebuild"], S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
@@ -3599,6 +4042,7 @@ export interface Opaque<Self, S extends Top, Brand> extends Bottom<Self, S["Enco
  * // person: Person
  * ```
  *
+ * @category constructors
  * @since 4.0.0
  */
 export declare function Opaque<Self, Brand = {}>(): <S extends Top>(schema: S) => Opaque<Self, S, Brand> & Omit<S, keyof Top>;
@@ -3606,7 +4050,8 @@ export declare function Opaque<Self, Brand = {}>(): <S extends Top>(schema: S) =
  * The type produced by {@link instanceOf} — a declaration schema that validates class instances.
  *
  * @see {@link instanceOf} for the constructor
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface instanceOf<T, Iso = T> extends declare<T, Iso> {
     readonly "Rebuild": instanceOf<T, Iso>;
@@ -3626,14 +4071,15 @@ export interface instanceOf<T, Iso = T> extends declare<T, Iso> {
  * // decoded: Date
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare function instanceOf<C extends abstract new (...args: any) => any, Iso = InstanceType<C>>(constructor: C, annotations?: Annotations.Declaration<InstanceType<C>> | undefined): instanceOf<InstanceType<C>, Iso>;
 /**
  * Constructs an `AST.Link` that describes how a value of type `T` encodes to and decodes from a `To` schema.
  * Used when building low-level AST transformations that bridge two schema types.
  *
+ * @category transforming
  * @since 4.0.0
  */
 export declare function link<T>(): <To extends Top>(encodeTo: To, transformation: {
@@ -3641,9 +4087,17 @@ export declare function link<T>(): <To extends Top>(encodeTo: To, transformation
     readonly encode: Getter.Getter<NoInfer<To["Type"]>, T>;
 }) => AST.Link;
 /**
- * Creates a custom filter check from a predicate function. The predicate
- * receives the input value, the schema's AST, and parse options, and returns
- * a value of type {@link FilterOutput}.
+ * Creates a custom validation filter from a predicate function.
+ *
+ * **Details**
+ * The predicate receives the decoded input value, the schema AST, and parse
+ * options, and returns a `FilterOutput`. Non-success outputs are normalized into
+ * schema issues. The `annotations` parameter annotates the filter itself; with
+ * the default formatter, failures use `message` first, `expected` second, and
+ * `<filter>` when neither is provided.
+ *
+ * When `abort` is `true`, parsing stops after this filter fails instead of
+ * collecting later check failures.
  *
  * **Example** (Failure at a nested path)
  *
@@ -3703,8 +4157,8 @@ export declare const makeFilter: <T>(filter: (input: T, ast: AST.AST, options: A
  *   {@link Issue.Issue}; the result is wrapped in an {@link Issue.Pointer}
  *   at the given `path`.
  *
- * @category model
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export type FilterIssue = string | Issue.Issue | {
     readonly path: ReadonlyArray<PropertyKey>;
@@ -3728,8 +4182,8 @@ export type FilterIssue = string | Issue.Issue | {
  *   to returning that element directly; otherwise the entries are grouped
  *   into an {@link Issue.Composite}.
  *
- * @category model
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export type FilterOutput = undefined | boolean | FilterIssue | ReadonlyArray<FilterIssue>;
 /**
@@ -3791,34 +4245,29 @@ export declare const isPattern: (regExp: globalThis.RegExp, annotations?: Annota
  */
 export declare const isStringFinite: (annotations?: Annotations.Filter) => AST.Filter<string>;
 /**
- * Validates that a string represents a valid BigInt (can be parsed as a BigInt).
- *
- * **JSON Schema**
+ * Validates that a string is a signed base-10 integer literal for Effect's
+ * BigInt string encoding.
  *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings representing BigInt values.
- *
- * **Arbitrary**
+ * **Details**
+ * The check uses the pattern `^-?\d+$`. It does not accept leading `+`, decimal
+ * points, exponent notation, separators, or non-decimal inputs such as
+ * hexadecimal strings.
  *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings match the BigInt string pattern.
+ * **JSON Schema**
+ * This check corresponds to a `pattern` constraint with the same signed
+ * base-10 integer pattern.
  *
  * @category String checks
  * @since 4.0.0
  */
 export declare const isStringBigInt: (annotations?: Annotations.Filter) => AST.Filter<string>;
 /**
- * Validates that a string represents a valid Symbol (can be parsed as a Symbol).
- *
- * **JSON Schema**
+ * Validates that a string has the `Symbol(description)` format used by Effect's
+ * symbol string encoding.
  *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings representing Symbol values.
- *
- * **Arbitrary**
- *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings match the Symbol string pattern.
+ * **Details**
+ * 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
  * @since 4.0.0
@@ -3897,119 +4346,84 @@ export declare function isBase64(annotations?: Annotations.Filter): AST.Filter<s
  */
 export declare function isBase64Url(annotations?: Annotations.Filter): AST.Filter<string>;
 /**
- * Validates that a string starts with the specified prefix.
- *
- * **JSON Schema**
+ * Validates at runtime that a string starts with the specified literal prefix.
  *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings starting with the specified prefix.
- *
- * **Arbitrary**
- *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings start with the required prefix.
+ * **Notes**
+ * The JSON Schema and arbitrary metadata are built from `^${startsWith}` without
+ * escaping regexp metacharacters. If the prefix contains regexp syntax, generated
+ * patterns may not be equivalent to the runtime `startsWith` check.
  *
  * @category String checks
  * @since 4.0.0
  */
 export declare function isStartsWith(startsWith: string, annotations?: Annotations.Filter): AST.Filter<string>;
 /**
- * Validates that a string ends with the specified suffix.
- *
- * **JSON Schema**
+ * Validates at runtime that a string ends with the specified literal suffix.
  *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings ending with the specified suffix.
- *
- * **Arbitrary**
- *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings end with the required suffix.
+ * **Notes**
+ * The JSON Schema and arbitrary metadata are built from `${endsWith}$` without
+ * escaping regexp metacharacters. If the suffix contains regexp syntax, generated
+ * patterns may not be equivalent to the runtime `endsWith` check.
  *
  * @category String checks
  * @since 4.0.0
  */
 export declare function isEndsWith(endsWith: string, annotations?: Annotations.Filter): AST.Filter<string>;
 /**
- * Validates that a string contains the specified substring.
+ * Validates at runtime that a string contains the specified literal substring.
  *
- * **JSON Schema**
- *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings containing the specified substring.
- *
- * **Arbitrary**
- *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings contain the required substring.
+ * **Notes**
+ * The JSON Schema and arbitrary metadata use the substring as a raw regexp
+ * pattern. If the substring contains regexp syntax, generated patterns may not be
+ * equivalent to the runtime `includes` check.
  *
  * @category String checks
  * @since 4.0.0
  */
 export declare function isIncludes(includes: string, annotations?: Annotations.Filter): AST.Filter<string>;
 /**
- * Validates that a string contains only uppercase characters.
- *
- * **JSON Schema**
- *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings with only uppercase characters.
- *
- * **Arbitrary**
+ * Validates that a string is unchanged by JavaScript's `toUpperCase()`.
  *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings contain only uppercase characters.
+ * **Details**
+ * This accepts empty strings and characters that do not have lowercase forms,
+ * such as digits, punctuation, and whitespace. It rejects strings that would
+ * change when uppercased.
  *
  * @category String checks
  * @since 4.0.0
  */
 export declare function isUppercased(annotations?: Annotations.Filter): AST.Filter<string>;
 /**
- * Validates that a string contains only lowercase characters.
+ * Validates that a string is unchanged by JavaScript's `toLowerCase()`.
  *
- * **JSON Schema**
- *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings with only lowercase characters.
- *
- * **Arbitrary**
- *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings contain only lowercase characters.
+ * **Details**
+ * This accepts empty strings and characters that do not have uppercase forms,
+ * such as digits, punctuation, and whitespace. It rejects strings that would
+ * change when lowercased.
  *
  * @category String checks
  * @since 4.0.0
  */
 export declare function isLowercased(annotations?: Annotations.Filter): AST.Filter<string>;
 /**
- * Validates that a string has its first character in uppercase.
- *
- * **JSON Schema**
- *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings with the first character in uppercase.
- *
- * **Arbitrary**
+ * Validates that the first character of a string is unchanged by
+ * `toUpperCase()`.
  *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings have the first character in uppercase.
+ * **Details**
+ * Empty strings pass. Strings whose first character has no lowercase form, such
+ * as a digit, punctuation mark, or whitespace, also pass.
  *
  * @category String checks
  * @since 4.0.0
  */
 export declare function isCapitalized(annotations?: Annotations.Filter): AST.Filter<string>;
 /**
- * Validates that a string has its first character in lowercase.
- *
- * **JSON Schema**
- *
- * This check corresponds to a `pattern` constraint in JSON Schema that matches
- * strings with the first character in lowercase.
- *
- * **Arbitrary**
+ * Validates that the first character of a string is unchanged by
+ * `toLowerCase()`.
  *
- * When generating test data with fast-check, this applies a `patterns`
- * constraint to ensure generated strings have the first character in lowercase.
+ * **Details**
+ * Empty strings pass. Strings whose first character has no uppercase form, such
+ * as a digit, punctuation mark, or whitespace, also pass.
  *
  * @category String checks
  * @since 4.0.0
@@ -4485,7 +4899,11 @@ export declare const isLessThanBigDecimal: (exclusiveMaximum: BigDecimal_.BigDec
  */
 export declare const isLessThanOrEqualToBigDecimal: (maximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => AST.Filter<BigDecimal_.BigDecimal>;
 /**
- * Validates that a BigDecimal is within a specified range.
+ * Validates that a `BigDecimal` is within a specified range.
+ *
+ * **Details**
+ * The minimum and maximum boundaries are inclusive by default. Pass
+ * `exclusiveMinimum` or `exclusiveMaximum` to exclude either boundary.
  *
  * @category BigDecimal checks
  * @since 4.0.0
@@ -4512,6 +4930,7 @@ export declare const isBetweenBigDecimal: (options: {
  * length.
  *
  * **Example** (Minimum length check)
+ *
  * ```ts
  * import { Schema } from "effect"
  *
@@ -4709,40 +5128,41 @@ export declare function isMaxProperties(maxProperties: number, annotations?: Ann
  */
 export declare function isPropertiesLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): AST.Filter<object>;
 /**
- * Validates that all property names in an object satisfy the provided key
- * schema (encoded side of the schema).
+ * Validates that every own property key of an object satisfies the encoded side
+ * of the provided key schema.
  *
- * **JSON Schema**
+ * **Details**
+ * This check uses `Reflect.ownKeys`, so symbol keys are validated in addition to
+ * string property names.
  *
- * This check corresponds to the `propertyNames` constraint in JSON Schema.
+ * **JSON Schema**
+ * For string property names, this corresponds to the `propertyNames` constraint
+ * in JSON Schema.
  *
  * @category Object checks
  * @since 4.0.0
  */
 export declare function isPropertyNames(keySchema: Top, annotations?: Annotations.Filter): AST.Filter<object>;
 /**
- * Validates that all items in an array are unique according to the provided
- * equivalence function.
+ * Validates that all items in an array are unique according to Effect equality.
  *
  * **JSON Schema**
- *
  * This check corresponds to the `uniqueItems: true` constraint in JSON Schema.
  *
  * **Arbitrary**
- *
- * When generating test data with fast-check, this applies a `comparator`
- * constraint using the provided equivalence function to ensure generated arrays
- * contain only unique items.
+ * When generating test data with fast-check, this applies a comparator based on
+ * Effect equality to ensure generated arrays contain only unique items.
  *
  * @category Array checks
  * @since 4.0.0
  */
 export declare function isUnique<T>(annotations?: Annotations.Filter): AST.Filter<readonly T[]>;
 /**
- * Companion type for {@link NonEmptyString}.
+ * Type-level representation of the `NonEmptyString` schema, which validates
+ * strings with a length of at least one.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface NonEmptyString extends String {
     readonly "Rebuild": NonEmptyString;
@@ -4752,14 +5172,15 @@ export interface NonEmptyString extends String {
  * character.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const NonEmptyString: NonEmptyString;
 /**
- * Companion type for {@link Char}.
+ * Type-level representation of the `Char` schema, which validates strings whose
+ * length is exactly one.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Char extends String {
     readonly "Rebuild": Char;
@@ -4768,7 +5189,7 @@ export interface Char extends String {
  * A schema representing a single character.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Char: Char;
 /**
@@ -4778,8 +5199,7 @@ export declare const Char: Char;
  * **Example** (Option schema)
  *
  * ```ts
- * import { Schema } from "effect"
- * import { Option } from "effect"
+ * import { Option, Schema } from "effect"
  *
  * const schema = Schema.Option(Schema.Number)
  *
@@ -4790,13 +5210,19 @@ export declare const Char: Char;
  * ```
  *
  * @category Option
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Option<A extends Top> extends declareConstructor<Option_.Option<A["Type"]>, Option_.Option<A["Encoded"]>, readonly [A], OptionIso<A>> {
     readonly "Rebuild": Option<A>;
     readonly value: A;
 }
 /**
+ * Iso representation used for `Option` schemas.
+ *
+ * **Details**
+ * `None` is represented as `{ _tag: "None" }`, while `Some` is represented as
+ * `{ _tag: "Some", value }` using the wrapped schema's `Iso` type.
+ *
  * @category Option
  * @since 4.0.0
  */
@@ -4810,14 +5236,15 @@ export type OptionIso<A extends Top> = {
  * Creates a schema for `Option<A>`. See {@link Option} for details.
  *
  * @category Option
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function Option<A extends Top>(value: A): Option<A>;
 /**
- * Companion type for {@link OptionFromNullOr}.
+ * Type-level representation of a schema that decodes `null` as `None` and all
+ * other values as `Some`.
  *
  * @category Option
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface OptionFromNullOr<S extends Top> extends decodeTo<Option<toType<S>>, NullOr<S>> {
     readonly "Rebuild": OptionFromNullOr<S>;
@@ -4834,14 +5261,15 @@ export interface OptionFromNullOr<S extends Top> extends decodeTo<Option<toType<
  * - `Some` is encoded as the value
  *
  * @category Option
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function OptionFromNullOr<S extends Top>(schema: S): OptionFromNullOr<S>;
 /**
- * Companion type for {@link OptionFromUndefinedOr}.
+ * Type-level representation of a schema that decodes `undefined` as `None` and
+ * all other values as `Some`.
  *
  * @category Option
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface OptionFromUndefinedOr<S extends Top> extends decodeTo<Option<toType<S>>, UndefinedOr<S>> {
     readonly "Rebuild": OptionFromUndefinedOr<S>;
@@ -4858,14 +5286,15 @@ export interface OptionFromUndefinedOr<S extends Top> extends decodeTo<Option<to
  * - `Some` is encoded as the value
  *
  * @category Option
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function OptionFromUndefinedOr<S extends Top>(schema: S): OptionFromUndefinedOr<S>;
 /**
- * Companion type for {@link OptionFromNullishOr}.
+ * Type-level representation of a schema that decodes `null` or `undefined` as
+ * `None` and all other values as `Some`.
  *
  * @category Option
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface OptionFromNullishOr<S extends Top> extends decodeTo<Option<toType<S>>, NullishOr<S>> {
     readonly "Rebuild": OptionFromNullishOr<S>;
@@ -4882,13 +5311,14 @@ export interface OptionFromNullishOr<S extends Top> extends decodeTo<Option<toTy
  * - `Some` is encoded as the value
  *
  * @category Option
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function OptionFromNullishOr<S extends Top>(schema: S, options?: {
     onNoneEncoding: null | undefined;
 }): OptionFromNullishOr<S>;
 /**
- * Companion type for {@link OptionFromOptionalKey}.
+ * Type-level representation of a schema that decodes a missing object key as
+ * `None` and a present key as `Some`.
  *
  * @category Option
  * @since 4.0.0
@@ -4912,7 +5342,8 @@ export interface OptionFromOptionalKey<S extends Top> extends decodeTo<Option<to
  */
 export declare function OptionFromOptionalKey<S extends Top>(schema: S): OptionFromOptionalKey<S>;
 /**
- * Companion type for {@link OptionFromOptional}.
+ * Type-level representation of a schema that decodes a missing key or
+ * `undefined` value as `None` and other present values as `Some`.
  *
  * @category Option
  * @since 4.0.0
@@ -4938,7 +5369,8 @@ export interface OptionFromOptional<S extends Top> extends decodeTo<Option<toTyp
  */
 export declare function OptionFromOptional<S extends Top>(schema: S): OptionFromOptional<S>;
 /**
- * Companion type for {@link OptionFromOptionalNullOr}.
+ * Type-level representation of a schema that decodes a missing key, `undefined`,
+ * or `null` as `None` and all other present values as `Some`.
  *
  * @category Option
  * @since 4.0.0
@@ -4981,6 +5413,12 @@ export interface Result<A extends Top, E extends Top> extends declareConstructor
     readonly failure: E;
 }
 /**
+ * Iso representation used for `Result` schemas.
+ *
+ * **Details**
+ * Successful results are represented as `{ _tag: "Success", success }`, while
+ * failed results are represented as `{ _tag: "Failure", failure }`.
+ *
  * @category Result
  * @since 4.0.0
  */
@@ -5003,7 +5441,7 @@ export declare function Result<A extends Top, E extends Top>(success: A, failure
  * values. The inner value is hidden from error messages.
  *
  * @category Redacted
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Redacted<S extends Top> extends declareConstructor<Redacted_.Redacted<S["Type"]>, Redacted_.Redacted<S["Encoded"]>, readonly [S]> {
     readonly "Rebuild": Redacted<S>;
@@ -5030,13 +5468,14 @@ export interface Redacted<S extends Top> extends declareConstructor<Redacted_.Re
  * but it will deserialize a value into a `Redacted` instance.
  *
  * @category Redacted
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function Redacted<S extends Top>(value: S, options?: {
     readonly label?: string | undefined;
 }): Redacted<S>;
 /**
- * Companion type for {@link RedactedFromValue}.
+ * Type-level representation of a schema that decodes a raw value with the
+ * provided schema and wraps the result in `Redacted`.
  *
  * @category Redacted
  * @since 4.0.0
@@ -5064,10 +5503,14 @@ export declare function RedactedFromValue<S extends Top>(value: S, options?: {
     readonly label?: string | undefined;
 }): RedactedFromValue<S>;
 /**
- * Schema for a single `Cause.Reason<E>`, representing one reason a fiber may
- * fail: a typed error (`Fail`), an unexpected defect (`Die`), or an interrupt
+ * Schema for a single `Cause.Reason`, representing one reason a fiber may fail:
+ * a typed error (`Fail`), an unexpected defect (`Die`), or an interrupt
  * (`Interrupt`).
  *
+ * **Details**
+ * The `error` schema validates typed failures and the `defect` schema validates
+ * unexpected defects.
+ *
  * @category CauseReason
  * @since 4.0.0
  */
@@ -5077,6 +5520,12 @@ export interface CauseReason<E extends Top, D extends Top> extends declareConstr
     readonly defect: D;
 }
 /**
+ * Iso representation used for `CauseReason` schemas.
+ *
+ * **Details**
+ * 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
  * @since 4.0.0
  */
@@ -5091,18 +5540,23 @@ export type CauseReasonIso<E extends Top, D extends Top> = {
     readonly fiberId: number | undefined;
 };
 /**
- * Creates a schema for `Cause.Reason<E>`. See {@link CauseReason} for details.
+ * Creates a schema for `Cause.Reason` values using separate schemas for typed
+ * failures and unexpected defects.
  *
  * @category CauseReason
  * @since 4.0.0
  */
 export declare function CauseReason<E extends Top, D extends Top>(error: E, defect: D): CauseReason<E, D>;
 /**
- * Schema for `Cause<E>`, an ordered collection of reasons a fiber failed,
- * combining typed errors, defects, and interrupts.
+ * Schema for `Cause` values, represented as an ordered collection of failure
+ * reasons combining typed errors, defects, and interrupts.
+ *
+ * **Details**
+ * The `error` schema validates typed failures and the `defect` schema validates
+ * unexpected defects.
  *
  * @category Cause
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Cause<E extends Top, D extends Top> extends declareConstructor<Cause_.Cause<E["Type"]>, Cause_.Cause<E["Encoded"]>, readonly [E, D], CauseIso<E, D>> {
     readonly "Rebuild": Cause<E, D>;
@@ -5110,19 +5564,23 @@ export interface Cause<E extends Top, D extends Top> extends declareConstructor<
     readonly defect: D;
 }
 /**
+ * Iso representation used for `Cause` schemas: an ordered array of
+ * `CauseReasonIso` values.
+ *
  * @category Cause
  * @since 4.0.0
  */
 export type CauseIso<E extends Top, D extends Top> = ReadonlyArray<CauseReasonIso<E, D>>;
 /**
- * Creates a schema for `Cause<E>`. See {@link Cause} for details.
+ * Creates a schema for `Cause` values using separate schemas for typed failures
+ * and unexpected defects.
  *
  * @category Cause
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function Cause<E extends Top, D extends Top>(error: E, defect: D): Cause<E, D>;
 /**
- * Companion type for {@link Error}.
+ * Type-level representation of the schema for JavaScript `Error` instances.
  *
  * @category Error
  * @since 4.0.0
@@ -5131,30 +5589,35 @@ export interface Error extends instanceOf<globalThis.Error> {
     readonly "Rebuild": Error;
 }
 /**
- * A schema that represents `Error` objects.
+ * A schema for JavaScript `Error` objects.
  *
- * The default json serializer decodes to a struct with `name` and `message`
- * properties (stack is omitted for security).
+ * **Default JSON serializer**
+ * Encodes an `Error` as an object with `message` and optional `name` properties,
+ * and decodes that object back into an `Error`. The stack trace is omitted from
+ * the encoded form for security.
  *
- * @category Schemas
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Error: Error;
 /**
- * A schema that represents `Error` objects.
+ * A schema for JavaScript `Error` objects that preserves stack traces in the JSON
+ * encoded form.
  *
- * The default json serializer decodes to a struct with `name`, `message` and
- * `stack` properties.
+ * **Default JSON serializer**
+ * Encodes an `Error` as an object with `message`, optional `name`, and optional
+ * `stack` properties, and decodes that object back into an `Error`.
  *
- * @category Schemas
+ * @category schemas
  * @since 4.0.0
  */
 export declare const ErrorWithStack: Error;
 /**
- * Companion type for {@link Defect}.
+ * Type-level representation of the `Defect` schema, which accepts JavaScript
+ * `Error` values and arbitrary unknown defect values.
  *
  * @category Defect
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Defect extends Union<readonly [
     decodeTo<Error, Struct<{
@@ -5167,10 +5630,15 @@ export interface Defect extends Union<readonly [
     readonly "Rebuild": Defect;
 }
 /**
- * A schema that represents defects.
+ * A schema for defect values, accepting either JavaScript `Error` values encoded
+ * with `message` and optional `name`, or arbitrary unknown defect values.
  *
- * @category Constructors
- * @since 4.0.0
+ * **Default JSON serializer**
+ * Unknown defects are serialized with `JSON.stringify` when possible and fall
+ * back to Effect's formatted representation when JSON serialization fails.
+ *
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const Defect: Defect;
 /**
@@ -5182,11 +5650,11 @@ export declare const Defect: Defect;
  */
 export declare const DefectWithStack: Defect;
 /**
- * Schema for `Exit<A, E>`, representing the result of a fiber execution —
- * either a success with value `A` or a failure with `Cause<E>`.
+ * Schema for `Exit` values, representing either a success with value `A` or a
+ * failure with a `Cause` containing typed errors and defects.
  *
  * @category Exit
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Exit<A extends Top, E extends Top, D extends Top> extends declareConstructor<Exit_.Exit<A["Type"], E["Type"]>, Exit_.Exit<A["Encoded"], E["Encoded"]>, readonly [A, E, D], ExitIso<A, E, D>> {
     readonly "Rebuild": Exit<A, E, D>;
@@ -5195,6 +5663,12 @@ export interface Exit<A extends Top, E extends Top, D extends Top> extends decla
     readonly defect: D;
 }
 /**
+ * Iso representation used for `Exit` schemas.
+ *
+ * **Details**
+ * Successful exits are represented as `{ _tag: "Success", value }`, while failed
+ * exits are represented as `{ _tag: "Failure", cause }`.
+ *
  * @category Exit
  * @since 4.0.0
  */
@@ -5206,14 +5680,16 @@ export type ExitIso<A extends Top, E extends Top, D extends Top> = {
     readonly cause: CauseIso<E, D>;
 };
 /**
- * Creates a schema for `Exit<A, E>`. See {@link Exit} for details.
+ * Creates a schema for `Exit` values using schemas for the success value, typed
+ * failure, and unexpected defect channels.
  *
  * @category Exit
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function Exit<A extends Top, E extends Top, D extends Top>(value: A, error: E, defect: D): Exit<A, E, D>;
 /**
- * Companion type for {@link ReadonlyMap}.
+ * Type-level representation of a `ReadonlyMap` schema whose keys and values are
+ * validated by the provided schemas.
  *
  * @category ReadonlyMap
  * @since 4.0.0
@@ -5224,6 +5700,9 @@ export interface $ReadonlyMap<Key extends Top, Value extends Top> extends declar
     readonly value: Value;
 }
 /**
+ * Iso representation used for `ReadonlyMap` schemas: an array of readonly
+ * `[key, value]` tuples using each entry schema's `Iso` type.
+ *
  * @category ReadonlyMap
  * @since 4.0.0
  */
@@ -5233,7 +5712,7 @@ export type ReadonlyMapIso<Key extends Top, Value extends Top> = ReadonlyArray<r
  * conform to the provided schemas.
  *
  * @category ReadonlyMap
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function ReadonlyMap<Key extends Top, Value extends Top>(key: Key, value: Value): $ReadonlyMap<Key, Value>;
 /**
@@ -5241,7 +5720,7 @@ export declare function ReadonlyMap<Key extends Top, Value extends Top>(key: Key
  * provided schemas.
  *
  * @category HashMap
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface HashMap<Key extends Top, Value extends Top> extends declareConstructor<HashMap_.HashMap<Key["Type"], Value["Type"]>, HashMap_.HashMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], HashMapIso<Key, Value>> {
     readonly "Rebuild": HashMap<Key, Value>;
@@ -5249,6 +5728,9 @@ export interface HashMap<Key extends Top, Value extends Top> extends declareCons
     readonly value: Value;
 }
 /**
+ * Iso representation used for `HashMap` schemas: an array of readonly
+ * `[key, value]` tuples using each entry schema's `Iso` type.
+ *
  * @category HashMap
  * @since 4.0.0
  */
@@ -5258,11 +5740,12 @@ export type HashMapIso<Key extends Top, Value extends Top> = ReadonlyArray<reado
  * conform to the provided schemas.
  *
  * @category HashMap
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function HashMap<Key extends Top, Value extends Top>(key: Key, value: Value): HashMap<Key, Value>;
 /**
- * Companion type for {@link ReadonlySet}.
+ * Type-level representation of a `ReadonlySet` schema whose values are validated
+ * by the provided element schema.
  *
  * @category ReadonlySet
  * @since 4.0.0
@@ -5272,13 +5755,19 @@ export interface $ReadonlySet<Value extends Top> extends declareConstructor<glob
     readonly value: Value;
 }
 /**
+ * Iso representation used for `ReadonlySet` schemas: an array of element values
+ * using the element schema's `Iso` type.
+ *
  * @category ReadonlySet
  * @since 4.0.0
  */
 export type ReadonlySetIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
 /**
+ * Creates a schema that validates a `ReadonlySet` whose values conform to the
+ * provided element schema.
+ *
  * @category ReadonlySet
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function ReadonlySet<Value extends Top>(value: Value): $ReadonlySet<Value>;
 /**
@@ -5286,13 +5775,16 @@ export declare function ReadonlySet<Value extends Top>(value: Value): $ReadonlyS
  * schema.
  *
  * @category HashSet
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface HashSet<Value extends Top> extends declareConstructor<HashSet_.HashSet<Value["Type"]>, HashSet_.HashSet<Value["Encoded"]>, readonly [Value], HashSetIso<Value>> {
     readonly "Rebuild": HashSet<Value>;
     readonly value: Value;
 }
 /**
+ * Iso representation used for `HashSet` schemas: an array of element values
+ * using the element schema's `Iso` type.
+ *
  * @category HashSet
  * @since 4.0.0
  */
@@ -5302,7 +5794,7 @@ export type HashSetIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
  * provided schema.
  *
  * @category HashSet
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function HashSet<Value extends Top>(value: Value): HashSet<Value>;
 /**
@@ -5310,13 +5802,16 @@ export declare function HashSet<Value extends Top>(value: Value): HashSet<Value>
  * must conform to the provided schema.
  *
  * @category Chunk
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Chunk<Value extends Top> extends declareConstructor<Chunk_.Chunk<Value["Type"]>, Chunk_.Chunk<Value["Encoded"]>, readonly [Value], ChunkIso<Value>> {
     readonly "Rebuild": Chunk<Value>;
     readonly value: Value;
 }
 /**
+ * Iso representation used for `Chunk` schemas: an array of element values using
+ * the element schema's `Iso` type.
+ *
  * @category Chunk
  * @since 4.0.0
  */
@@ -5326,11 +5821,11 @@ export type ChunkIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
  * provided schema.
  *
  * @category Chunk
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare function Chunk<Value extends Top>(value: Value): Chunk<Value>;
 /**
- * Companion type for {@link RegExp}.
+ * Type-level representation of the schema for JavaScript `RegExp` instances.
  *
  * @category RegExp
  * @since 4.0.0
@@ -5348,7 +5843,7 @@ export interface RegExp extends instanceOf<globalThis.RegExp> {
  */
 export declare const RegExp: RegExp;
 /**
- * Companion type for {@link URL}.
+ * Type-level representation of the schema for JavaScript `URL` instances.
  *
  * @category URL
  * @since 4.0.0
@@ -5363,12 +5858,13 @@ export interface URL extends instanceOf<globalThis.URL> {
  *
  * - encodes `URL` as a `string`
  *
- * @since 4.0.0
  * @category URL
+ * @since 4.0.0
  */
 export declare const URL: URL;
 /**
- * Companion type for {@link URLFromString}.
+ * Type-level representation of a transformation schema that decodes valid URL
+ * strings into JavaScript `URL` instances.
  *
  * @category URL
  * @since 4.0.0
@@ -5390,7 +5886,8 @@ export interface URLFromString extends decodeTo<URL, String> {
  */
 export declare const URLFromString: URLFromString;
 /**
- * Companion type for {@link Date}.
+ * Type-level representation of the schema for JavaScript `Date` instances,
+ * including invalid dates.
  *
  * @category Date
  * @since 4.0.0
@@ -5401,9 +5898,10 @@ export interface Date extends instanceOf<globalThis.Date> {
 /**
  * A schema for JavaScript `Date` objects.
  *
- * This schema accepts any `Date` instance, including invalid dates (e.g., `new
- * Date("invalid")`). For validating only valid dates, use {@link DateValid}
- * instead. The default JSON serializer encodes `Date` as an ISO 8601 string.
+ * This schema accepts any `Date` instance, including invalid dates. For
+ * validating only valid dates, use `DateValid` instead. The default JSON
+ * serializer encodes valid dates as ISO 8601 strings; invalid dates encode as
+ * `"Invalid Date"`.
  *
  * **Example** (Date schema)
  *
@@ -5419,29 +5917,33 @@ export interface Date extends instanceOf<globalThis.Date> {
  */
 export declare const Date: Date;
 /**
- * Companion type for {@link DateFromString}.
+ * Type-level representation of a transformation schema that decodes strings into
+ * JavaScript `Date` instances.
  *
  * @category Date
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface DateFromString extends decodeTo<Date, String> {
     readonly "Rebuild": DateFromString;
 }
 /**
- * A transformation schema that parses an ISO 8601 string into a `Date`.
+ * A transformation schema that decodes a string into a JavaScript `Date`.
  *
- * Decoding:
- * - A `string` is decoded as a `Date`.
+ * **Decoding**
+ * The string is passed to JavaScript `Date` construction and may decode to an
+ * invalid `Date`. Compose with `DateValid` when invalid dates should be rejected.
  *
- * Encoding:
- * - A `Date` is encoded as a `string`.
+ * **Encoding**
+ * A valid `Date` is encoded as an ISO string; an invalid `Date` is encoded as
+ * `"Invalid Date"`.
  *
  * @category Date
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const DateFromString: DateFromString;
 /**
- * Companion type for {@link DateValid}.
+ * Type-level representation of the `DateValid` schema, which accepts only valid
+ * JavaScript `Date` instances.
  *
  * @category Date
  * @since 4.0.0
@@ -5460,10 +5962,10 @@ export interface DateValid extends Date {
  */
 export declare const DateValid: DateValid;
 /**
- * Companion type for {@link Duration}.
+ * Type-level representation of the schema for Effect `Duration` values.
  *
  * @category Duration
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Duration extends declare<Duration_.Duration> {
     readonly "Rebuild": Duration;
@@ -5477,8 +5979,7 @@ export interface Duration extends declare<Duration_.Duration> {
  * **Example** (Duration schema)
  *
  * ```ts
- * import { Schema } from "effect"
- * import { Duration } from "effect"
+ * import { Duration, Schema } from "effect"
  *
  * Schema.decodeUnknownSync(Schema.Duration)(Duration.seconds(5))
  * // => Duration(5s)
@@ -5486,11 +5987,12 @@ export interface Duration extends declare<Duration_.Duration> {
  *
  * @category Duration
  *
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Duration: Duration;
 /**
- * Companion type for {@link DurationFromString}.
+ * Type-level representation of a transformation schema that decodes strings
+ * accepted by `Duration.fromInput` into `Duration` values.
  *
  * @category Duration
  * @since 4.0.0
@@ -5513,33 +6015,37 @@ export interface DurationFromString extends decodeTo<Duration, String> {
  */
 export declare const DurationFromString: DurationFromString;
 /**
- * Companion type for {@link DurationFromNanos}.
+ * Type-level representation of a transformation schema that decodes non-negative
+ * nanosecond `bigint` values into `Duration` values.
  *
  * @category Duration
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
     readonly "Rebuild": DurationFromNanos;
 }
 /**
  * A transformation schema that decodes a non-negative `bigint` into a
- * `Duration`, treating the `bigint` value as the duration in nanoseconds.
+ * `Duration`, treating the bigint as nanoseconds.
  *
- * Decoding:
- * - A non-negative `bigint` representing nanoseconds is decoded as a `Duration`
+ * **Decoding**
+ * A non-negative `bigint` representing nanoseconds is decoded as a `Duration`.
  *
- * Encoding:
- * - A `Duration` is encoded to a non-negative `bigint` representing nanoseconds
+ * **Encoding**
+ * Finite durations are encoded as a non-negative `bigint` number of nanoseconds.
+ * Encoding fails when the duration cannot be represented as nanoseconds, such as
+ * `Duration.infinity`.
  *
  * @category Duration
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const DurationFromNanos: DurationFromNanos;
 /**
- * Companion type for {@link DurationFromMillis}.
+ * Type-level representation of a transformation schema that decodes
+ * non-negative millisecond numbers into `Duration` values.
  *
  * @category Duration
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface DurationFromMillis extends decodeTo<Duration, Number> {
     readonly "Rebuild": DurationFromMillis;
@@ -5558,14 +6064,14 @@ export interface DurationFromMillis extends decodeTo<Duration, Number> {
  *   representing milliseconds
  *
  * @category Duration
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const DurationFromMillis: DurationFromMillis;
 /**
- * Companion type for {@link BigDecimal}.
+ * Type-level representation of the schema for Effect `BigDecimal` values.
  *
  * @category BigDecimal
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface BigDecimal extends declare<BigDecimal_.BigDecimal> {
     readonly "Rebuild": BigDecimal;
@@ -5578,11 +6084,12 @@ export interface BigDecimal extends declare<BigDecimal_.BigDecimal> {
  * - encodes `BigDecimal` as a `string`
  *
  * @category BigDecimal
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const BigDecimal: BigDecimal;
 /**
- * Companion type for {@link BigDecimalFromString}.
+ * Type-level representation of a transformation schema that decodes strings into
+ * `BigDecimal` values.
  *
  * @category BigDecimal
  * @since 4.0.0
@@ -5604,7 +6111,8 @@ export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
  */
 export declare const BigDecimalFromString: BigDecimalFromString;
 /**
- * Companion type for {@link UnknownFromJsonString}.
+ * Type-level representation of a transformation schema that decodes
+ * JSON-encoded strings into `unknown` values.
  *
  * @category JSON
  * @since 4.0.0
@@ -5623,7 +6131,7 @@ export interface UnknownFromJsonString extends fromJsonString<Unknown> {
  * - Any value is encoded as a JSON string using `JSON.stringify`.
  * - If the value is not a valid JSON value, encoding fails.
  *
- * **Example**
+ * **Example** (Decoding unknown JSON strings)
  *
  * ```ts
  * import { Schema } from "effect"
@@ -5637,7 +6145,8 @@ export interface UnknownFromJsonString extends fromJsonString<Unknown> {
  */
 export declare const UnknownFromJsonString: UnknownFromJsonString;
 /**
- * Companion type for {@link fromJsonString}.
+ * Type-level representation of a schema that parses a JSON string and then
+ * decodes the parsed value with the provided schema.
  *
  * @category JSON
  * @since 4.0.0
@@ -5655,7 +6164,7 @@ export interface fromJsonString<S extends Top> extends decodeTo<S, String> {
  * The resulting schema first parses the input string as JSON, and then runs the
  * provided schema on the parsed result.
  *
- * **Example**
+ * **Example** (Decoding JSON strings with a schema)
  *
  * ```ts
  * import { Schema } from "effect"
@@ -5673,7 +6182,7 @@ export interface fromJsonString<S extends Top> extends decodeTo<S, String> {
  * resulting schema will be a JSON Schema with a `contentSchema` property that
  * contains the JSON Schema for the given schema.
  *
- * **Example**
+ * **Example** (Emitting JSON Schema for a JSON string decoder)
  *
  * ```ts
  * import { Schema } from "effect"
@@ -5711,7 +6220,7 @@ export interface fromJsonString<S extends Top> extends decodeTo<S, String> {
  */
 export declare function fromJsonString<S extends Top>(schema: S): fromJsonString<S>;
 /**
- * Companion type for {@link File}.
+ * Type-level representation of the schema for JavaScript `File` instances.
  *
  * @category File
  * @since 4.0.0
@@ -5730,7 +6239,7 @@ export interface File extends instanceOf<globalThis.File> {
  */
 export declare const File: File;
 /**
- * Companion type for {@link FormData}.
+ * Type-level representation of the schema for JavaScript `FormData` instances.
  *
  * @category FormData
  * @since 4.0.0
@@ -5749,7 +6258,8 @@ export interface FormData extends instanceOf<globalThis.FormData> {
  */
 export declare const FormData: FormData;
 /**
- * Companion type for {@link fromFormData}.
+ * Type-level representation of a schema that parses `FormData` into a tree
+ * record and then decodes it with the provided schema.
  *
  * @category FormData
  * @since 4.0.0
@@ -5838,11 +6348,13 @@ export interface fromFormData<S extends Top> extends decodeTo<S, FormData> {
  * // Success({"a":1}) // Note: the value is a number
  * ```
  *
+ * @category decoding
  * @since 4.0.0
  */
 export declare function fromFormData<S extends Top>(schema: S): fromFormData<S>;
 /**
- * Companion type for {@link URLSearchParams}.
+ * Type-level representation of the schema for JavaScript `URLSearchParams`
+ * instances.
  *
  * @category URLSearchParams
  * @since 4.0.0
@@ -5860,7 +6372,8 @@ export interface URLSearchParams extends instanceOf<globalThis.URLSearchParams>
  */
 export declare const URLSearchParams: URLSearchParams;
 /**
- * Companion type for {@link fromURLSearchParams}.
+ * Type-level representation of a schema that parses `URLSearchParams` into a
+ * tree record and then decodes it with the provided schema.
  *
  * @category URLSearchParams
  * @since 4.0.0
@@ -5940,14 +6453,16 @@ export interface fromURLSearchParams<S extends Top> extends decodeTo<S, URLSearc
  * // Success({"a":1}) // Note: the value is a number
  * ```
  *
+ * @category decoding
  * @since 4.0.0
  */
 export declare function fromURLSearchParams<S extends Top>(schema: S): fromURLSearchParams<S>;
 /**
- * Companion type for {@link Finite}.
+ * Type-level representation of the `Finite` number schema, which rejects `NaN`,
+ * `Infinity`, and `-Infinity`.
  *
  * @category Number
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Finite extends Number {
     readonly "Rebuild": Finite;
@@ -5956,14 +6471,15 @@ export interface Finite extends Number {
  * A schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.
  *
  * @category Number
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Finite: Finite;
 /**
- * Companion type for {@link Int}.
+ * Type-level representation of the `Int` schema, which accepts only finite
+ * integer numbers.
  *
  * @category Number
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Int extends Number {
     readonly "Rebuild": Int;
@@ -5972,33 +6488,38 @@ export interface Int extends Number {
  * A schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.
  *
  * @category Number
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Int: Int;
 /**
- * Companion type for {@link NumberFromString}.
+ * Type-level representation of a transformation schema that decodes strings into
+ * numbers using JavaScript number coercion.
  *
  * @category Number
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface NumberFromString extends decodeTo<Finite, String> {
     readonly "Rebuild": NumberFromString;
 }
 /**
- * A transformation schema that parses a string into a number.
+ * A transformation schema that parses a string into a `number` using JavaScript
+ * number coercion.
  *
- * Decoding:
- * - A `string` is decoded as a finite number.
+ * **Decoding**
+ * A `string` is decoded as a number, including possible non-finite values such as
+ * `NaN`, `Infinity`, and `-Infinity`. Use `FiniteFromString` to reject non-finite
+ * numbers.
  *
- * Encoding:
- * - A number is encoded as a `string`.
+ * **Encoding**
+ * A number is encoded as a `string`.
  *
  * @category Number
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const NumberFromString: NumberFromString;
 /**
- * Companion type for {@link FiniteFromString}.
+ * Type-level representation of a transformation schema that decodes strings into
+ * finite numbers.
  *
  * @category Number
  * @since 4.0.0
@@ -6021,7 +6542,8 @@ export interface FiniteFromString extends decodeTo<Finite, String> {
  */
 export declare const FiniteFromString: FiniteFromString;
 /**
- * Companion type for {@link BigIntFromString}.
+ * Type-level representation of a transformation schema that decodes strings into
+ * `bigint` values.
  *
  * @category BigInt
  * @since 4.0.0
@@ -6043,10 +6565,11 @@ export interface BigIntFromString extends decodeTo<BigInt, String> {
  */
 export declare const BigIntFromString: BigIntFromString;
 /**
- * Companion type for {@link Trimmed}.
+ * Schema interface for `Trimmed`, representing strings with no leading or
+ * trailing whitespace.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Trimmed extends String {
     readonly "Rebuild": Trimmed;
@@ -6055,14 +6578,15 @@ export interface Trimmed extends String {
  * A schema for strings that contains no leading or trailing whitespaces.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Trimmed: Trimmed;
 /**
- * Companion type for {@link Trim}.
+ * Schema interface for `Trim`, a transformation that trims leading and trailing
+ * whitespace while decoding and encodes the trimmed string unchanged.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Trim extends decodeTo<Trimmed, String> {
     readonly "Rebuild": Trim;
@@ -6077,14 +6601,15 @@ export interface Trim extends decodeTo<Trimmed, String> {
  * - The trimmed string is encoded as is.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Trim: Trim;
 /**
- * Companion type for {@link StringFromBase64}.
+ * Schema interface for `StringFromBase64`, a transformation between RFC4648
+ * base64-encoded strings and UTF-8 strings.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface StringFromBase64 extends decodeTo<String, String> {
     readonly "Rebuild": StringFromBase64;
@@ -6099,14 +6624,15 @@ export interface StringFromBase64 extends decodeTo<String, String> {
  * - A `string` is encoded as a base64-encoded string.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const StringFromBase64: StringFromBase64;
 /**
- * Companion type for {@link StringFromBase64Url}.
+ * Schema interface for `StringFromBase64Url`, a transformation between URL-safe
+ * base64-encoded strings and UTF-8 strings.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface StringFromBase64Url extends decodeTo<String, String> {
     readonly "Rebuild": StringFromBase64Url;
@@ -6121,14 +6647,15 @@ export interface StringFromBase64Url extends decodeTo<String, String> {
  * - A `string` is encoded as a base64 (URL) encoded string.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const StringFromBase64Url: StringFromBase64Url;
 /**
- * Companion type for {@link StringFromHex}.
+ * Schema interface for `StringFromHex`, a transformation between hex-encoded
+ * strings and UTF-8 strings.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface StringFromHex extends decodeTo<String, String> {
     readonly "Rebuild": StringFromHex;
@@ -6143,14 +6670,15 @@ export interface StringFromHex extends decodeTo<String, String> {
  * - A `string` is encoded as a hex string.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const StringFromHex: StringFromHex;
 /**
- * Companion type for {@link StringFromUriComponent}.
+ * Schema interface for `StringFromUriComponent`, a transformation between
+ * URI-component encoded strings and UTF-8 strings.
  *
  * @category String
- * @since 4.0.0
+ * @since 3.12.0
  */
 export interface StringFromUriComponent extends decodeTo<String, String> {
     readonly "Rebuild": StringFromUriComponent;
@@ -6165,7 +6693,7 @@ export interface StringFromUriComponent extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a URI component encoded string.
  *
- * **Example**
+ * **Example** (Decoding URI component strings)
  *
  * ```ts
  * import { Schema } from "effect"
@@ -6184,17 +6712,23 @@ export interface StringFromUriComponent extends decodeTo<String, String> {
  * ```
  *
  * @category String
- * @since 4.0.0
+ * @since 3.12.0
  */
 export declare const StringFromUriComponent: StringFromUriComponent;
 /**
- * A union schema for JavaScript property keys: `number | symbol | string`.
+ * A union schema for property keys accepted by Effect schemas: finite `number`,
+ * `symbol`, or `string`.
  *
  * @category PropertyKey
  * @since 4.0.0
  */
 export declare const PropertyKey: Union<readonly [Finite, Symbol, String]>;
 /**
+ * Schema for a Standard Schema v1 failure result.
+ *
+ * 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 StandardSchema
  * @since 4.0.0
  */
@@ -6207,7 +6741,8 @@ export declare const StandardSchemaV1FailureResult: Struct<{
     }>>;
 }>;
 /**
- * Companion type for {@link BooleanFromBit}.
+ * Schema interface for `BooleanFromBit`, a transformation between bit literals
+ * `0 | 1` and boolean values.
  *
  * @category Boolean
  * @since 4.0.0
@@ -6223,7 +6758,8 @@ export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0,
  */
 export declare const BooleanFromBit: BooleanFromBit;
 /**
- * Companion type for {@link Uint8Array}.
+ * Schema interface for `Uint8Array`, representing JavaScript `Uint8Array`
+ * instances with base64 JSON encoding.
  *
  * @category Uint8Array
  * @since 4.0.0
@@ -6243,10 +6779,11 @@ export interface Uint8Array extends instanceOf<globalThis.Uint8Array<ArrayBuffer
  */
 export declare const Uint8Array: Uint8Array;
 /**
- * Companion type for {@link Uint8ArrayFromBase64}.
+ * Schema interface for `Uint8ArrayFromBase64`, a transformation between
+ * base64-encoded strings and `Uint8Array` values.
  *
  * @category Uint8Array
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
     readonly "Rebuild": Uint8ArrayFromBase64;
@@ -6262,14 +6799,15 @@ export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
  * - A `Uint8Array` is encoded as a base64-encoded string.
  *
  * @category Uint8Array
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Uint8ArrayFromBase64: Uint8ArrayFromBase64;
 /**
- * Companion type for {@link Uint8ArrayFromBase64Url}.
+ * Schema interface for `Uint8ArrayFromBase64Url`, a transformation between
+ * URL-safe base64-encoded strings and `Uint8Array` values.
  *
  * @category Uint8Array
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Uint8ArrayFromBase64Url extends decodeTo<Uint8Array, String> {
     readonly "Rebuild": Uint8ArrayFromBase64Url;
@@ -6285,14 +6823,15 @@ export interface Uint8ArrayFromBase64Url extends decodeTo<Uint8Array, String> {
  * - A `Uint8Array` is encoded as a base64 (URL) encoded string.
  *
  * @category Uint8Array
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Uint8ArrayFromBase64Url: Uint8ArrayFromBase64Url;
 /**
- * Companion type for {@link Uint8ArrayFromHex}.
+ * Schema interface for `Uint8ArrayFromHex`, a transformation between
+ * hex-encoded strings and `Uint8Array` values.
  *
  * @category Uint8Array
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface Uint8ArrayFromHex extends decodeTo<Uint8Array, String> {
     readonly "Rebuild": Uint8ArrayFromHex;
@@ -6308,14 +6847,15 @@ export interface Uint8ArrayFromHex extends decodeTo<Uint8Array, String> {
  * - A `Uint8Array` is encoded as a hex encoded string.
  *
  * @category Uint8Array
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const Uint8ArrayFromHex: Uint8ArrayFromHex;
 /**
- * Companion type for {@link DateTimeUtc}.
+ * Schema interface for `DateTimeUtc`, representing `DateTime.Utc` values with
+ * UTC ISO string JSON encoding.
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface DateTimeUtc extends declare<DateTime.Utc> {
     readonly "Rebuild": DateTimeUtc;
@@ -6328,14 +6868,15 @@ export interface DateTimeUtc extends declare<DateTime.Utc> {
  * - encodes `DateTime.Utc` as a UTC ISO string
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const DateTimeUtc: DateTimeUtc;
 /**
- * Companion type for {@link DateTimeUtcFromDate}.
+ * Schema interface for `DateTimeUtcFromDate`, a transformation from valid
+ * JavaScript `Date` values to `DateTime.Utc`.
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.12.0
  */
 export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
     readonly "Rebuild": DateTimeUtcFromDate;
@@ -6350,11 +6891,12 @@ export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
  * - A `DateTime.Utc` is encoded as a `Date`
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.12.0
  */
 export declare const DateTimeUtcFromDate: DateTimeUtcFromDate;
 /**
- * Companion type for {@link DateTimeUtcFromString}.
+ * Schema interface for `DateTimeUtcFromString`, a transformation from date-time
+ * strings to `DateTime.Utc`.
  *
  * @category DateTime
  * @since 4.0.0
@@ -6363,22 +6905,24 @@ export interface DateTimeUtcFromString extends decodeTo<DateTimeUtc, String> {
     readonly "Rebuild": DateTimeUtcFromString;
 }
 /**
- * A transformation schema that decodes a string into a `DateTime.Utc`.
+ * A transformation schema that decodes a date-time string into a `DateTime.Utc`.
  *
  * Decoding:
- * - A `string` that can be parsed by `Date.parse` is decoded as a
- *   `DateTime.Utc`
+ *
+ * - A string accepted by `DateTime.make` is parsed and normalized to UTC. Strings
+ *   without an explicit zone are interpreted as UTC.
  *
  * Encoding:
- * - A `DateTime.Utc` is encoded as a `string` in ISO 8601 format, ignoring any
- *   time zone.
+ *
+ * - A `DateTime.Utc` is encoded as a UTC ISO 8601 string.
  *
  * @category DateTime
  * @since 4.0.0
  */
 export declare const DateTimeUtcFromString: DateTimeUtcFromString;
 /**
- * Companion type for {@link DateTimeUtcFromMillis}.
+ * Schema interface for `DateTimeUtcFromMillis`, a transformation between epoch
+ * milliseconds and `DateTime.Utc` values.
  *
  * @category DateTime
  * @since 4.0.0
@@ -6400,10 +6944,11 @@ export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>
  */
 export declare const DateTimeUtcFromMillis: DateTimeUtcFromMillis;
 /**
- * Companion type for {@link TimeZoneOffset}.
+ * Schema interface for `TimeZoneOffset`, representing
+ * `DateTime.TimeZone.Offset` values encoded as offset milliseconds.
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface TimeZoneOffset extends declare<DateTime.TimeZone.Offset> {
     readonly "Rebuild": TimeZoneOffset;
@@ -6416,14 +6961,15 @@ export interface TimeZoneOffset extends declare<DateTime.TimeZone.Offset> {
  * - encodes `DateTime.TimeZone.Offset` as a number (offset in milliseconds)
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const TimeZoneOffset: TimeZoneOffset;
 /**
- * Companion type for {@link TimeZoneNamed}.
+ * Schema interface for `TimeZoneNamed`, representing
+ * `DateTime.TimeZone.Named` values encoded as IANA time zone identifiers.
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface TimeZoneNamed extends declare<DateTime.TimeZone.Named> {
     readonly "Rebuild": TimeZoneNamed;
@@ -6436,11 +6982,12 @@ export interface TimeZoneNamed extends declare<DateTime.TimeZone.Named> {
  * - encodes `DateTime.TimeZone.Named` as a string (IANA time zone identifier)
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const TimeZoneNamed: TimeZoneNamed;
 /**
- * Companion type for {@link TimeZoneNamedFromString}.
+ * Schema interface for `TimeZoneNamedFromString`, a transformation between IANA
+ * time zone identifier strings and `DateTime.TimeZone.Named` values.
  *
  * @category DateTime
  * @since 4.0.0
@@ -6462,10 +7009,11 @@ export interface TimeZoneNamedFromString extends decodeTo<TimeZoneNamed, String>
  */
 export declare const TimeZoneNamedFromString: TimeZoneNamedFromString;
 /**
- * Companion type for {@link TimeZone}.
+ * Schema interface for `TimeZone`, representing `DateTime.TimeZone` values
+ * encoded as either IANA identifiers or numeric offset strings.
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface TimeZone extends declare<DateTime.TimeZone> {
     readonly "Rebuild": TimeZone;
@@ -6479,11 +7027,12 @@ export interface TimeZone extends declare<DateTime.TimeZone> {
  *   `+03:00`)
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const TimeZone: TimeZone;
 /**
- * Companion type for {@link TimeZoneFromString}.
+ * Schema interface for `TimeZoneFromString`, a transformation from IANA
+ * identifier or offset strings to `DateTime.TimeZone` values.
  *
  * @category DateTime
  * @since 4.0.0
@@ -6505,10 +7054,11 @@ export interface TimeZoneFromString extends decodeTo<TimeZone, String> {
  */
 export declare const TimeZoneFromString: TimeZoneFromString;
 /**
- * Companion type for {@link DateTimeZoned}.
+ * Schema interface for `DateTimeZoned`, representing `DateTime.Zoned` values
+ * with ISO offset or named-zone string JSON encoding.
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export interface DateTimeZoned extends declare<DateTime.Zoned> {
     readonly "Rebuild": DateTimeZoned;
@@ -6518,15 +7068,18 @@ export interface DateTimeZoned extends declare<DateTime.Zoned> {
  *
  * **Default JSON serializer**
  *
- * - encodes `DateTime.Zoned` as a string in the format
+ * - encodes offset zones as an ISO date-time with a numeric offset, such as
+ *   `YYYY-MM-DDTHH:mm:ss.sss+HH:MM`
+ * - encodes named zones by appending the IANA identifier in brackets, such as
  *   `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`
  *
  * @category DateTime
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare const DateTimeZoned: DateTimeZoned;
 /**
- * Companion type for {@link DateTimeZonedFromString}.
+ * Schema interface for `DateTimeZonedFromString`, a transformation between
+ * zoned date-time strings and `DateTime.Zoned` values.
  *
  * @category DateTime
  * @since 4.0.0
@@ -6556,7 +7109,8 @@ export declare const DateTimeZonedFromString: DateTimeZonedFromString;
  * The interface exposes the schema's `fields`, an `identifier` string, and
  * helpers such as `mapFields`, `annotate`, `check`, and `extend`.
  *
- * @since 4.0.0
+ * @category models
+ * @since 3.10.0
  */
 export interface Class<Self, S extends Top & {
     readonly fields: Struct.Fields;
@@ -6626,8 +7180,8 @@ type MissingSelfGeneric<Usage extends string> = `Missing \`Self\` generic - use
  * console.log(dog.breed) // "Labrador"
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const Class: {
     /**
@@ -6671,8 +7225,8 @@ export declare const Class: {
      * console.log(dog.breed) // "Labrador"
      * ```
      *
-     * @category Constructors
-     * @since 4.0.0
+     * @category constructors
+     * @since 3.10.0
      */
     <Self = never, Brand = {}>(identifier: string): {
         /**
@@ -6716,8 +7270,8 @@ export declare const Class: {
          * console.log(dog.breed) // "Labrador"
          * ```
          *
-         * @category Constructors
-         * @since 4.0.0
+         * @category constructors
+         * @since 3.10.0
          */
         <const Fields extends Struct.Fields>(fields: Fields, annotations?: Annotations.Declaration<Self, readonly [Struct<Fields>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.Class"> : Class<Self, Struct<Fields>, Brand>;
         /**
@@ -6761,8 +7315,8 @@ export declare const Class: {
          * console.log(dog.breed) // "Labrador"
          * ```
          *
-         * @category Constructors
-         * @since 4.0.0
+         * @category constructors
+         * @since 3.10.0
          */
         <S extends Struct<Struct.Fields>>(schema: S, annotations?: Annotations.Declaration<Self, readonly [S]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.Class"> : Class<Self, S, Brand>;
     };
@@ -6789,8 +7343,8 @@ export declare const Class: {
  * console.log(c.radius) // 5
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const TaggedClass: {
     /**
@@ -6815,8 +7369,8 @@ export declare const TaggedClass: {
      * console.log(c.radius) // 5
      * ```
      *
-     * @category Constructors
-     * @since 4.0.0
+     * @category constructors
+     * @since 3.10.0
      */
     <Self = never, Brand = {}>(identifier?: string): {
         /**
@@ -6841,8 +7395,8 @@ export declare const TaggedClass: {
          * console.log(c.radius) // 5
          * ```
          *
-         * @category Constructors
-         * @since 4.0.0
+         * @category constructors
+         * @since 3.10.0
          */
         <Tag extends string, const Fields extends Struct.Fields>(tag: Tag, fields: Fields, annotations?: Annotations.Declaration<Self, readonly [TaggedStruct<Tag, Fields>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedClass"> : Class<Self, TaggedStruct<Tag, Fields>, Brand>;
         /**
@@ -6867,8 +7421,8 @@ export declare const TaggedClass: {
          * console.log(c.radius) // 5
          * ```
          *
-         * @category Constructors
-         * @since 4.0.0
+         * @category constructors
+         * @since 3.10.0
          */
         <Tag extends string, S extends Struct<Struct.Fields>>(tag: Tag, schema: S, annotations?: Annotations.Declaration<Self, readonly [Struct<Simplify<{
             readonly _tag: tag<Tag>;
@@ -6897,7 +7451,7 @@ export declare const TaggedClass: {
  * })
  * ```
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare const ErrorClass: {
@@ -6921,7 +7475,7 @@ export declare const ErrorClass: {
      * })
      * ```
      *
-     * @category Constructors
+     * @category constructors
      * @since 4.0.0
      */
     <Self = never, Brand = {}>(identifier: string): {
@@ -6945,7 +7499,7 @@ export declare const ErrorClass: {
          * })
          * ```
          *
-         * @category Constructors
+         * @category constructors
          * @since 4.0.0
          */
         <const Fields extends Struct.Fields>(fields: Fields, annotations?: Annotations.Declaration<Self, readonly [Struct<Fields>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.ErrorClass"> : Class<Self, Struct<Fields>, Cause_.YieldableError & Brand>;
@@ -6969,7 +7523,7 @@ export declare const ErrorClass: {
          * })
          * ```
          *
-         * @category Constructors
+         * @category constructors
          * @since 4.0.0
          */
         <S extends Struct<Struct.Fields>>(schema: S, annotations?: Annotations.Declaration<Self, readonly [S]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.ErrorClass"> : Class<Self, S, Cause_.YieldableError & Brand>;
@@ -6994,8 +7548,8 @@ export declare const ErrorClass: {
  * })
  * ```
  *
- * @category Constructors
- * @since 4.0.0
+ * @category constructors
+ * @since 3.10.0
  */
 export declare const TaggedErrorClass: {
     /**
@@ -7017,8 +7571,8 @@ export declare const TaggedErrorClass: {
      * })
      * ```
      *
-     * @category Constructors
-     * @since 4.0.0
+     * @category constructors
+     * @since 3.10.0
      */
     <Self = never, Brand = {}>(identifier?: string): {
         /**
@@ -7040,8 +7594,8 @@ export declare const TaggedErrorClass: {
          * })
          * ```
          *
-         * @category Constructors
-         * @since 4.0.0
+         * @category constructors
+         * @since 3.10.0
          */
         <Tag extends string, const Fields extends Struct.Fields>(tag: Tag, fields: Fields, annotations?: Annotations.Declaration<Self, readonly [TaggedStruct<Tag, Fields>]>): [Self] extends [never] ? MissingSelfGeneric<"Schema.TaggedErrorClass"> : Class<Self, TaggedStruct<Tag, Fields>, Cause_.YieldableError & Brand>;
         /**
@@ -7063,8 +7617,8 @@ export declare const TaggedErrorClass: {
          * })
          * ```
          *
-         * @category Constructors
-         * @since 4.0.0
+         * @category constructors
+         * @since 3.10.0
          */
         <Tag extends string, S extends Struct<Struct.Fields>>(tag: Tag, schema: S, annotations?: Annotations.Declaration<Self, readonly [Struct<Simplify<{
             readonly _tag: tag<Tag>;
@@ -7116,10 +7670,11 @@ export declare function toArbitraryLazy<S extends Top>(schema: S): LazyArbitrary
  */
 export declare function toArbitrary<S extends Top>(schema: S): FastCheck.Arbitrary<S["Type"]>;
 /**
- * **Technical Note**
+ * Annotates a schema with a custom formatter used by `toFormatter`.
  *
- * This annotation cannot be added to `Annotations.Bottom` because it would make
- * the schema invariant.
+ * Use this when the formatter derived from the schema structure is not suitable.
+ * The annotation is applied through this helper because adding it directly to
+ * `Annotations.Bottom` would make schemas invariant.
  *
  * @category Formatter
  * @since 4.0.0
@@ -7180,6 +7735,7 @@ export declare function toRepresentation(schema: Top): SchemaRepresentation.Docu
 /**
  * Options for {@link toJsonSchemaDocument}.
  *
+ * @category models
  * @since 4.0.0
  */
 export interface ToJsonSchemaOptions {
@@ -7200,17 +7756,19 @@ export interface ToJsonSchemaOptions {
     readonly generateDescriptions?: boolean | undefined;
 }
 /**
- * Returns a JSON Schema Document (draft-2020-12).
+ * Returns a JSON Schema document using draft 2020-12.
  *
- * You can use the `options` parameter to return a different target JSON Schema.
+ * The `options` parameter controls generation details such as additional
+ * properties and synthesized check descriptions; it does not change the draft
+ * target.
  *
  * @category JsonSchema
  * @since 4.0.0
  */
 export declare function toJsonSchemaDocument(schema: Top, options?: ToJsonSchemaOptions): JsonSchema.Document<"draft-2020-12">;
 /**
- * Derives a canonical JSON codec from a schema. The encoded form is `unknown`
- * (any JSON-compatible value), decoded to the schema's `Type`.
+ * Derives a canonical JSON codec from a schema. The encoded form is `Json`, and
+ * decoding produces the schema's `Type`.
  *
  * @category Canonical Codecs
  * @since 4.0.0
@@ -7267,9 +7825,11 @@ type XmlEncoderOptions = {
     readonly sortKeys?: boolean | undefined;
 };
 /**
- * Derives an XML encoder from a codec. Encodes a value to an XML string by
- * first converting it through {@link toCodecStringTree}, then serializing the
- * resulting tree to XML.
+ * Derives an XML encoder from a codec.
+ *
+ * The returned function encodes a value through `toCodecStringTree` and returns
+ * an `Effect` that succeeds with the XML string or fails with `SchemaError` if
+ * codec encoding fails.
  *
  * @category Canonical Codecs
  * @since 4.0.0
@@ -7331,6 +7891,9 @@ export declare function overrideToCodecIso<S extends Top, Iso>(to: Codec<Iso>, t
  */
 export declare function toDifferJsonPatch<T, E>(schema: Codec<T, E>): Differ<T, JsonPatch.JsonPatch>;
 /**
+ * Recursive tree type whose leaves are `Node` values and whose branches are
+ * readonly arrays or string-keyed records of child trees.
+ *
  * @category Tree
  * @since 4.0.0
  */
@@ -7398,6 +7961,9 @@ export interface JsonObject {
  */
 export declare const Json: Codec<Json>;
 /**
+ * Recursive TypeScript type for mutable JSON values: `null`, `number`,
+ * `boolean`, `string`, mutable arrays, or mutable string-keyed records.
+ *
  * @category JSON
  * @since 4.0.0
  */
@@ -7454,7 +8020,7 @@ export declare function resolveAnnotationsKey<S extends Top>(schema: S): Annotat
  * Use {@link resolveAnnotations} to read the annotations attached to a schema at
  * runtime.
  *
- * @since 4.0.0
+ * @since 3.10.0
  */
 export declare namespace Annotations {
     /**
@@ -7495,8 +8061,8 @@ export declare namespace Annotations {
      * }
      * ```
      *
-     * @category Model
-     * @since 4.0.0
+     * @category models
+     * @since 3.10.0
      */
     interface Annotations {
         readonly [x: string]: unknown;
@@ -7505,9 +8071,19 @@ export declare namespace Annotations {
      * Annotations shared by all schema nodes. These map to common JSON Schema /
      * OpenAPI fields: `title`, `description`, `format`, etc.
      *
+     * @category models
      * @since 4.0.0
      */
     interface Augment extends Annotations {
+        /**
+         * Human-readable description of what a value is expected to satisfy.
+         *
+         * For filter and refinement failures, the default formatter uses
+         * `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>`.
+         */
         readonly expected?: string | undefined;
         readonly title?: string | undefined;
         readonly description?: string | undefined;
@@ -7521,6 +8097,7 @@ export declare namespace Annotations {
     /**
      * Extends {@link Augment} with type-parametric `default` and `examples` fields.
      *
+     * @category models
      * @since 4.0.0
      */
     interface Documentation<T> extends Augment {
@@ -7532,7 +8109,7 @@ export declare namespace Annotations {
      * with an optional `messageMissingKey` to override the error message when
      * the property key is absent during decoding.
      *
-     * @category Model
+     * @category models
      * @since 4.0.0
      */
     interface Key<T> extends Documentation<T> {
@@ -7547,18 +8124,36 @@ export declare namespace Annotations {
      * arbitrary generation hooks. {@link Declaration} and other annotation
      * interfaces build on top of this.
      *
-     * @category Model
+     * @category models
      * @since 4.0.0
      */
     interface Bottom<T, TypeParameters extends ReadonlyArray<Top>> extends Documentation<T> {
         /**
-         * The message to use when the value is invalid.
+         * Complete message to use when this schema node reports an issue.
+         *
+         * This replaces the default message for matching issue types instead of
+         * 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.
          */
         readonly message?: string | undefined;
         /**
          * The message to use when a key is unexpected.
          */
         readonly messageUnexpectedKey?: string | undefined;
+        /**
+         * Stable identifier for this schema node.
+         *
+         * 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`.
+         *
+         * `identifier` does not name a failed filter or refinement. If the base
+         * type matches and a filter fails, put `expected` or `message` on the
+         * filter/refinement instead.
+         */
         readonly identifier?: string | undefined;
         readonly parseOptions?: AST.ParseOptions | undefined;
         /**
@@ -7572,17 +8167,27 @@ export declare namespace Annotations {
         readonly toArbitrary?: ToArbitrary.Declaration<T, TypeParameters> | undefined;
     }
     /**
+     * Helpers for projecting declaration type-parameter schemas into decoded or
+     * encoded codec arrays used by annotation hooks.
+     *
      * @since 4.0.0
      */
     namespace TypeParameters {
         /**
-         * @since 4.0.0
+         * Maps declaration type-parameter schemas to codecs for their decoded `Type`
+         * values.
+         *
+         * @category utility types
+         * @since 3.10.0
          */
         type Type<TypeParameters extends ReadonlyArray<Top>> = {
             readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Type"]>;
         };
         /**
-         * @since 4.0.0
+         * Maps declaration type-parameter schemas to codecs for their `Encoded` values.
+         *
+         * @category utility types
+         * @since 3.10.0
          */
         type Encoded<TypeParameters extends ReadonlyArray<Top>> = {
             readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Encoded"]>;
@@ -7595,7 +8200,7 @@ export declare namespace Annotations {
      * derived capabilities (JSON encoding, property testing, etc.) can be
      * provided for the custom type.
      *
-     * @category Model
+     * @category models
      * @since 4.0.0
      */
     interface Declaration<T, TypeParameters extends ReadonlyArray<Top> = readonly []> extends Bottom<T, TypeParameters> {
@@ -7620,11 +8225,25 @@ export declare namespace Annotations {
      * {@link Augment} with an optional error message, identifier, and metadata.
      * Filters are intentionally non-parametric to keep them covariant.
      *
-     * @category Model
-     * @since 4.0.0
+     * @category models
+     * @since 3.10.0
      */
     interface Filter extends Augment {
+        /**
+         * Complete message to use when this filter or refinement fails.
+         *
+         * The default formatter checks filter annotations in this order:
+         * `message`, then `expected`, then `<filter>`.
+         */
         readonly message?: string | undefined;
+        /**
+         * Stable identifier for the schema after this filter is attached.
+         *
+         * This can affect schema tooling such as JSON Schema generation and
+         * type-level failures before the filter runs, but it does not name the
+         * failed filter itself. For filter failure messages, use `expected` or
+         * `message`.
+         */
         readonly identifier?: string | undefined;
         /**
          * Optional metadata used to identify or extend the filter with custom data.
@@ -7641,38 +8260,65 @@ export declare namespace Annotations {
         readonly "~structural"?: boolean | undefined;
     }
     /**
+     * Types used by arbitrary-derivation annotations to configure `toArbitrary`
+     * hooks and carry merged fast-check constraints.
+     *
      * @since 4.0.0
      */
     namespace ToArbitrary {
         /**
+         * fast-check string constraints plus optional regular-expression pattern strings
+         * used when deriving string arbitraries from schema checks.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface StringConstraints extends FastCheck.StringSharedConstraints {
             readonly patterns?: readonly [string, ...Array<string>];
         }
         /**
+         * fast-check floating-point constraints plus `isInteger`, which switches
+         * derived number arbitraries to integer generation.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface NumberConstraints extends FastCheck.FloatConstraints {
             readonly isInteger?: boolean;
         }
         /**
+         * fast-check bigint constraints used when deriving arbitraries for bigint
+         * schemas.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface BigIntConstraints extends FastCheck.BigIntConstraints {
         }
         /**
+         * fast-check array constraints plus an optional comparator used when deriving
+         * unique-array arbitraries.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface ArrayConstraints extends FastCheck.ArrayConstraints {
             readonly comparator?: (a: any, b: any) => boolean;
         }
         /**
+         * fast-check date constraints used when deriving arbitraries for `Date` and
+         * DateTime schemas.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface DateConstraints extends FastCheck.DateConstraints {
         }
         /**
+         * Grouped arbitrary-generation constraints accumulated from schema checks and
+         * passed to `toArbitrary` derivation.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface Constraint {
@@ -7683,7 +8329,12 @@ export declare namespace Annotations {
             readonly date?: DateConstraints | undefined;
         }
         /**
-         * @since 4.0.0
+         * Context passed to arbitrary-derivation hooks, including accumulated
+         * constraints and an `isSuspend` flag used to limit recursion for suspended
+         * schemas.
+         *
+         * @category models
+         * @since 3.10.0
          */
         interface Context {
             /**
@@ -7695,6 +8346,12 @@ export declare namespace Annotations {
             readonly constraints?: ToArbitrary.Constraint | undefined;
         }
         /**
+         * Hook signature for declaration schema arbitrary annotations.
+         *
+         * Given arbitraries for any type parameters, returns a function that receives the
+         * fast-check module and derivation context and produces an arbitrary for `T`.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface Declaration<T, TypeParameters extends ReadonlyArray<Top>> {
@@ -7704,10 +8361,18 @@ export declare namespace Annotations {
         }
     }
     /**
+     * Types used by formatter annotations to customize formatter derivation for
+     * declaration schemas.
+     *
      * @since 4.0.0
      */
     namespace ToFormatter {
         /**
+         * Hook signature for declaration schema formatter annotations.
+         *
+         * Given formatters for any type parameters, returns a formatter for `T`.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface Declaration<T, TypeParameters extends ReadonlyArray<Top>> {
@@ -7717,10 +8382,18 @@ export declare namespace Annotations {
         }
     }
     /**
+     * Types used by equivalence annotations to customize equivalence derivation for
+     * declaration schemas.
+     *
      * @since 4.0.0
      */
     namespace ToEquivalence {
         /**
+         * Hook signature for declaration schema equivalence annotations.
+         *
+         * Given equivalences for any type parameters, returns an `Equivalence` for `T`.
+         *
+         * @category models
          * @since 4.0.0
          */
         interface Declaration<T, TypeParameters extends ReadonlyArray<Top>> {
@@ -7730,15 +8403,23 @@ export declare namespace Annotations {
         }
     }
     /**
-     * @category Model
+     * Annotations that can be attached to schema issues.
+     *
+     * The optional `message` field overrides the default issue message.
+     *
+     * @category models
      * @since 4.0.0
      */
     interface Issue extends Annotations {
         readonly message?: string | undefined;
     }
     /**
-     * This MUST NOT be extended with custom meta.
+     * Registry of metadata payloads emitted by built-in schema filters and checks.
+     *
+     * Do not augment this interface with custom metadata; extend `MetaDefinitions`
+     * instead.
      *
+     * @category models
      * @since 4.0.0
      */
     interface BuiltInMetaDefinitions {
@@ -7940,17 +8621,27 @@ export declare namespace Annotations {
         };
     }
     /**
+     * Union of all metadata payloads defined by `BuiltInMetaDefinitions`.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type BuiltInMeta = BuiltInMetaDefinitions[keyof BuiltInMetaDefinitions];
     /**
-     * This MAY be extended with custom meta.
+     * Augmentable registry of schema filter metadata payloads.
+     *
+     * Extend this interface to add custom values accepted by annotation `meta`
+     * fields.
      *
+     * @category models
      * @since 4.0.0
      */
     interface MetaDefinitions extends BuiltInMetaDefinitions {
     }
     /**
+     * Union of built-in and user-augmented schema filter metadata payloads.
+     *
+     * @category utility types
      * @since 4.0.0
      */
     type Meta = MetaDefinitions[keyof MetaDefinitions];