effect 4.0.0-beta.73 → 4.0.0-beta.75

package/dist/Schema.d.ts

@@ -108,10 +108,10 @@ import * as Order from "./Order.ts";
 import * as Pipeable from "./Pipeable.ts";
 import * as Redacted_ from "./Redacted.ts";
 import * as Result_ from "./Result.ts";
-import * as AST from "./SchemaAST.ts";
-import * as Getter from "./SchemaGetter.ts";
-import * as Issue from "./SchemaIssue.ts";
-import * as Parser from "./SchemaParser.ts";
+import * as SchemaAST from "./SchemaAST.ts";
+import * as SchemaGetter from "./SchemaGetter.ts";
+import * as SchemaIssue from "./SchemaIssue.ts";
+import * as SchemaParser from "./SchemaParser.ts";
 import type * as SchemaRepresentation from "./SchemaRepresentation.ts";
 import type { Assign, Lambda, Mutable, Simplify } from "./Struct.ts";
 import * as Struct_ from "./Struct.ts";
@@ -159,14 +159,14 @@ export type ConstructorDefault = "no-default" | "with-default";
  * @see {@link Bottom.makeEffect}
  * @see {@link Bottom.make}
  *
- * @category models
+ * @category options
  * @since 3.13.4
  */
 export interface MakeOptions {
     /**
      * The parse options to use for the schema.
      */
-    readonly parseOptions?: AST.ParseOptions | undefined;
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined;
     /**
      * Whether to disable validation for the schema.
      */
@@ -191,7 +191,7 @@ export interface MakeOptions {
  * @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 {
+export interface Bottom<out T, out E, out RD, out RE, out Ast extends SchemaAST.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 {
     readonly [TypeId]: typeof TypeId;
     readonly "ast": Ast;
     readonly "Rebuild": Rebuild;
@@ -210,7 +210,7 @@ export interface Bottom<out T, out E, out RD, out RE, out Ast extends AST.AST, o
     readonly "~encoded.optionality": EncodedOptionality;
     annotate(annotations: Annotations.Bottom<this["Type"], this["~type.parameters"]>): this["Rebuild"];
     annotateKey(annotations: Annotations.Key<this["Type"]>): this["Rebuild"];
-    check(...checks: readonly [AST.Check<this["Type"]>, ...Array<AST.Check<this["Type"]>>]): this["Rebuild"];
+    check(...checks: readonly [SchemaAST.Check<this["Type"]>, ...Array<SchemaAST.Check<this["Type"]>>]): this["Rebuild"];
     rebuild(ast: this["ast"]): this["Rebuild"];
     /**
      * Constructs a value from the make input representation synchronously.
@@ -267,20 +267,23 @@ export interface Bottom<out T, out E, out RD, out RE, out Ast extends AST.AST, o
     makeEffect(input: this["~type.make.in"], options?: MakeOptions): Effect.Effect<this["Type"], SchemaError>;
 }
 /**
- * The schema type returned by {@link declareConstructor}, tracking the decoded
- * type `T`, the encoded type `E`, and the list of type-parameter schemas
- * `TypeParameters`.
+ * Type-level representation returned by {@link declareConstructor}.
  *
  * @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> {
+export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<Top>, Iso = T> extends Bottom<T, E, TypeParameters[number]["DecodingServices"], TypeParameters[number]["EncodingServices"], SchemaAST.Declaration, declareConstructor<T, E, TypeParameters, Iso>, T, Iso, TypeParameters> {
 }
 /**
  * Creates a schema for a **parametric** type (a generic container such as
  * `Array<A>`, `Option<A>`, etc.) by accepting a list of type-parameter schemas
  * and a decoder factory.
  *
+ * **When to use**
+ *
+ * Use when you are defining a schema for a generic container whose validation
+ * depends on one or more type-parameter schemas.
+ *
  * **Details**
  *
  * The outer call `declareConstructor<T, E, Iso>()` fixes the decoded type `T`,
@@ -310,7 +313,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
  *     ([itemCodec]) =>
  *       (u, ast, options) => {
  *         if (!isBox(u)) {
- *           return Effect.fail(new Issue.InvalidType(ast, Option.some(u)))
+ *           return Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(u)))
  *         }
  *         return Effect.map(
  *           SchemaParser.decodeUnknownEffect(itemCodec)(u.value, options),
@@ -325,10 +328,9 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
  * @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>;
+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: SchemaAST.Declaration, options: SchemaAST.ParseOptions) => Effect.Effect<T, SchemaIssue.Issue>, annotations?: Annotations.Declaration<T, TypeParameters>) => declareConstructor<T, E, TypeParameters, Iso>;
 /**
- * The schema type returned by {@link declare}, representing a non-parametric
- * opaque type `T` with no type parameters.
+ * Type-level representation returned by {@link declare}.
  *
  * @category constructors
  * @since 3.13.3
@@ -341,10 +343,10 @@ export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [
  * function. The schema accepts any unknown value and succeeds when `is` returns
  * `true`, failing with an `InvalidType` issue otherwise.
  *
- * **Details**
+ * **When to use**
  *
- * Use this when the type has no type parameters. For parametric types such as
- * `Option<A>` or `Array<A>`, use {@link declareConstructor} instead.
+ * Use when you are defining a schema for an opaque type with no type parameters
+ * and validation can be expressed as a type guard.
  *
  * **Example** (Schema for a custom `UserId` branded type)
  *
@@ -394,7 +396,7 @@ export declare function declare<T, Iso = T>(is: (u: unknown) => u is T, annotati
  * type E = typeof bottom["Encoded"]  // string
  * ```
  *
- * @category utils
+ * @category utility types
  * @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"]>;
@@ -507,7 +509,7 @@ export declare function annotateKey<S extends Top>(annotations: Annotations.Key<
  * @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
+export interface Top extends Bottom<unknown, unknown, unknown, unknown, SchemaAST.AST, Top, unknown, unknown, any, // this is because TypeParameters is invariant
 unknown, Mutability, Optionality, ConstructorDefault, Mutability, Optionality> {
 }
 /**
@@ -763,7 +765,7 @@ export interface Encoder<out E, out RE = never> extends Codec<unknown, E, unknow
  * type Enc = typeof codec["Encoded"] // string
  * ```
  *
- * @category utils
+ * @category utility types
  * @since 4.0.0
  */
 export declare function revealCodec<T, E, RD, RE>(codec: Codec<T, E, RD, RE>): Codec<T, E, RD, RE>;
@@ -774,7 +776,7 @@ export {
  *
  * **Details**
  *
- * The `issue` field contains a structured {@link Issue.Issue} tree describing
+ * The `issue` field contains a structured {@link SchemaIssue.Issue} tree describing
  * every validation failure, including the path to the problematic value,
  * expected types, and actual values received. `message` renders the issue tree
  * as a human-readable string.
@@ -885,9 +887,9 @@ export declare function isSchemaError(u: unknown): u is SchemaError;
  * @since 4.0.0
  */
 export declare function toStandardSchemaV1<S extends Decoder<unknown>>(self: S, options?: {
-    readonly leafHook?: Issue.LeafHook | undefined;
-    readonly checkHook?: Issue.CheckHook | undefined;
-    readonly parseOptions?: AST.ParseOptions | undefined;
+    readonly leafHook?: SchemaIssue.LeafHook | undefined;
+    readonly checkHook?: SchemaIssue.CheckHook | undefined;
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined;
 }): StandardSchemaV1<S["Encoded"], S["Type"]> & S;
 /**
  * Converts a schema to an experimental Standard JSON Schema V1 representation.
@@ -931,7 +933,7 @@ export declare function toStandardJSONSchemaV1<S extends Top>(self: S): Standard
  * @category guards
  * @since 3.10.0
  */
-export declare const is: typeof Parser.is;
+export declare const is: typeof SchemaParser.is;
 /**
  * Creates an assertion function that throws an error if the input doesn't match
  * the schema.
@@ -939,7 +941,7 @@ export declare const is: typeof Parser.is;
  * **When to use**
  *
  * Use to validate unknown input at runtime while narrowing the value with a
- * TypeScript `asserts` predicate.
+ * TypeScript assertion signature.
  *
  * **Details**
  *
@@ -976,7 +978,8 @@ export declare const asserts: <S extends Top, I>(schema: S, input: I) => asserts
  *
  * **When to use**
  *
- * Use when decoding input whose type is not statically known.
+ * Use when you need to decode unknown input in an `Effect` whose failure
+ * channel is `SchemaError`.
  *
  * **Details**
  *
@@ -985,10 +988,12 @@ export declare const asserts: <S extends Top, I>(schema: S, input: I) => asserts
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownEffect<S extends Top>(schema: S, options?: AST.ParseOptions): (input: unknown, options?: AST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
+export declare function decodeUnknownEffect<S extends Top>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.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
@@ -996,7 +1001,8 @@ export declare function decodeUnknownEffect<S extends Top>(schema: S, options?:
  *
  * **When to use**
  *
- * Use when the input is already typed as the schema's `Encoded` type.
+ * Use when you need to decode input already typed as the schema's `Encoded`
+ * type in an `Effect` whose failure channel is `SchemaError`.
  *
  * **Details**
  *
@@ -1004,10 +1010,12 @@ export declare function decodeUnknownEffect<S extends Top>(schema: S, options?:
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeEffect} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-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"]>;
+export declare const decodeEffect: <S extends Top>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.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
@@ -1015,8 +1023,8 @@ export declare const decodeEffect: <S extends Top>(schema: S, options?: AST.Pars
  *
  * **When to use**
  *
- * Use when the input type is not statically known and decoding should return an
- * `Exit` instead of failing or throwing.
+ * Use when you need to decode unknown input into an `Exit` whose failure
+ * contains `SchemaError`.
  *
  * **Details**
  *
@@ -1026,10 +1034,12 @@ export declare const decodeEffect: <S extends Top>(schema: S, options?: AST.Pars
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeUnknownExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
+export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.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
@@ -1037,8 +1047,8 @@ export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S,
  *
  * **When to use**
  *
- * Use when typed input should be decoded into an `Exit` instead of failing or
- * throwing.
+ * Use when you need to decode already typed `Encoded` input into an `Exit`
+ * whose failure contains `SchemaError`.
  *
  * **Details**
  *
@@ -1047,30 +1057,33 @@ export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S,
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeExit: <S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
+export declare const decodeExit: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.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.
  *
  * **When to use**
  *
- * Use when the input type is not statically known and you only need to know
+ * Use when you do not know the input type statically and only need to know
  * whether decoding succeeded.
  *
  * **Details**
  *
  * Prefer this over {@link decodeUnknownExit} or {@link decodeUnknownEffect}
- * when you don't need error details. For typed input use {@link decodeOption}.
+ * when you don't need error details. For input already typed as the schema's
+ * `Encoded` type use {@link decodeOption}.
  * 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 decodeUnknownOption: typeof Parser.decodeUnknownOption;
+export declare const decodeUnknownOption: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]>;
 /**
  * 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
@@ -1078,7 +1091,8 @@ export declare const decodeUnknownOption: typeof Parser.decodeUnknownOption;
  *
  * **When to use**
  *
- * Use when typed input should be decoded and only success or failure matters.
+ * Use when you already have input typed as the schema's `Encoded` type and
+ * only need to know whether decoding succeeded.
  *
  * **Details**
  *
@@ -1089,35 +1103,38 @@ export declare const decodeUnknownOption: typeof Parser.decodeUnknownOption;
  * @category decoding
  * @since 3.10.0
  */
-export declare const decodeOption: <S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Encoded"], options?: AST.ParseOptions) => Option_.Option<S["Type"]>;
+export declare const decodeOption: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]>;
 /**
  * Decodes an `unknown` input against a schema, returning a `Result` that
- * succeeds with the decoded value or fails with a schema issue.
+ * succeeds with the decoded value or fails with a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when the input type is not statically known and decoding should return a
- * `Result` with structured issue data.
+ * Use when you do not know the input type statically and want decoding to
+ * return a `Result` with `SchemaError` failure data.
  *
  * **Details**
  *
- * For typed input use {@link decodeResult}.
+ * For input already typed as the schema's `Encoded` type use
+ * {@link decodeResult}.
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeUnknownResult} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeUnknownResult: typeof Parser.decodeUnknownResult;
+export declare function decodeUnknownResult<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError>;
 /**
  * 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.
+ * {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when typed input should be decoded into a `Result` with structured issue
- * data.
+ * Use when you already have input typed as the schema's `Encoded` type and
+ * want decoding to return a `Result` with `SchemaError` failure data.
  *
  * **Details**
  *
@@ -1125,36 +1142,44 @@ export declare const decodeUnknownResult: typeof Parser.decodeUnknownResult;
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeResult} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-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>;
+export declare const decodeResult: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError>;
 /**
  * Decodes an `unknown` input against a schema, returning a `Promise` that
- * resolves with the decoded value or rejects with a schema issue.
+ * resolves with the decoded value or rejects with a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when integrating unknown input validation with Promise-based APIs.
+ * Use when you need decoding of unknown input to return a JavaScript `Promise`
+ * that rejects with `SchemaError`.
  *
  * **Details**
  *
- * For typed input use {@link decodePromise}.
+ * For input already typed as the schema's `Encoded` type use
+ * {@link decodePromise}.
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeUnknownPromise} for the adapter that rejects with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 3.10.0
  */
-export declare const decodeUnknownPromise: typeof Parser.decodeUnknownPromise;
+export declare function decodeUnknownPromise<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Promise<S["Type"]>;
 /**
  * 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
- * schema issue.
+ * {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when integrating typed input decoding with Promise-based APIs.
+ * Use when you already have input typed as the schema's `Encoded` type and
+ * need decoding to return a JavaScript `Promise` that rejects with
+ * `SchemaError`.
  *
  * **Details**
  *
@@ -1162,22 +1187,24 @@ export declare const decodeUnknownPromise: typeof Parser.decodeUnknownPromise;
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodePromise} for the adapter that rejects with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 3.10.0
  */
-export declare const decodePromise: typeof Parser.decodePromise;
+export declare const decodePromise: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Promise<S["Type"]>;
 /**
  * Decodes an `unknown` input against a schema synchronously, returning the
- * decoded value or throwing an `Error` whose cause contains the schema issue.
+ * decoded value or throwing a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when validating unknown data at a boundary and treating schema mismatches
- * as exceptions.
+ * Use when you need to validate unknown data at a synchronous boundary and want
+ * schema mismatches to throw `SchemaError`.
  *
  * **Details**
  *
- * For typed input use `decodeSync`.
+ * For input already typed as the schema's `Encoded` type use `decodeSync`.
  * 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
@@ -1200,19 +1227,20 @@ export declare const decodePromise: typeof Parser.decodePromise;
  * //         └─ Expected a numeric string, actual "not a number"
  * ```
  *
+ * @see {@link SchemaParser.decodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
+ *
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeUnknownSync: typeof Parser.decodeUnknownSync;
+export declare function decodeUnknownSync<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Type"];
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema
- * synchronously, returning the decoded value or throwing an `Error` whose cause
- * contains the schema issue.
+ * synchronously, returning the decoded value or throwing a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when typed input should be decoded synchronously and schema mismatches
- * should throw.
+ * Use when you already have input typed as the schema's `Encoded` type and
+ * want schema mismatches to throw `SchemaError` synchronously.
  *
  * **Details**
  *
@@ -1221,21 +1249,24 @@ export declare const decodeUnknownSync: typeof Parser.decodeUnknownSync;
  * provided either when creating the decoder or when applying it; application
  * options override creation options.
  *
+ * @see {@link SchemaParser.decodeSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
+ *
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeSync: <S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Encoded"], options?: AST.ParseOptions) => S["Type"];
+export declare const decodeSync: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.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}.
  *
  * **When to use**
  *
- * Use when encoding input whose type is not statically known.
+ * Use when you need to encode unknown input in an `Effect` whose failure
+ * channel is `SchemaError`.
  *
  * **Details**
  *
- * Prefer {@link encodeEffect} when the input is already typed as the schema's
+ * Prefer {@link encodeEffect} when the value 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.
@@ -1251,10 +1282,12 @@ export declare const decodeSync: <S extends Decoder<unknown>>(schema: S, options
  * // Output: "42"
  * ```
  *
+ * @see {@link SchemaParser.encodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownEffect<S extends Top>(schema: S, options?: AST.ParseOptions): (input: unknown, options?: AST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
+export declare function encodeUnknownEffect<S extends Top>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.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
@@ -1262,7 +1295,8 @@ export declare function encodeUnknownEffect<S extends Top>(schema: S, options?:
  *
  * **When to use**
  *
- * Use when the input is already typed as the schema's `Type`.
+ * Use when you need to encode input already typed as the schema's `Type` in
+ * an `Effect` whose failure channel is `SchemaError`.
  *
  * **Details**
  *
@@ -1270,10 +1304,12 @@ export declare function encodeUnknownEffect<S extends Top>(schema: S, options?:
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeEffect} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-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"]>;
+export declare const encodeEffect: <S extends Top>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.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
@@ -1281,20 +1317,22 @@ export declare const encodeEffect: <S extends Top>(schema: S, options?: AST.Pars
  *
  * **When to use**
  *
- * Use when the input type is not statically known and encoding should return an
- * `Exit` instead of failing or throwing.
+ * Use when you need to encode unknown input into an `Exit` whose failure
+ * contains `SchemaError`.
  *
  * **Details**
  *
  * Only usable with schemas that have no `EncodingServices` requirement. Prefer
- * {@link encodeExit} when the input is already typed as the schema's `Type`.
+ * {@link encodeExit} when the value 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.
  *
+ * @see {@link SchemaParser.encodeUnknownExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions): (input: unknown, options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
+export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.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
@@ -1302,8 +1340,8 @@ export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S,
  *
  * **When to use**
  *
- * Use when typed input should be encoded into an `Exit` instead of failing or
- * throwing.
+ * Use when you need to encode already typed schema values into an `Exit` whose
+ * failure contains `SchemaError`.
  *
  * **Details**
  *
@@ -1312,30 +1350,33 @@ export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S,
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeExit: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
+export declare const encodeExit: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.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.
  *
  * **When to use**
  *
- * Use when the input type is not statically known and you only need to know
+ * Use when you do not know the input type statically and only need to know
  * whether encoding succeeded.
  *
  * **Details**
  *
  * Prefer this over {@link encodeUnknownExit} or {@link encodeUnknownEffect}
- * when you don't need error details. For typed input use {@link encodeOption}.
+ * when you don't need error details. For values already typed as the schema's
+ * `Type` use {@link encodeOption}.
  * 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 encodeUnknownOption: typeof Parser.encodeUnknownOption;
+export declare const encodeUnknownOption: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]>;
 /**
  * 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
@@ -1343,7 +1384,8 @@ export declare const encodeUnknownOption: typeof Parser.encodeUnknownOption;
  *
  * **When to use**
  *
- * Use when typed input should be encoded and only success or failure matters.
+ * Use when you already have a value typed as the schema's `Type` and only need
+ * to know whether encoding succeeded.
  *
  * **Details**
  *
@@ -1354,34 +1396,37 @@ export declare const encodeUnknownOption: typeof Parser.encodeUnknownOption;
  * @category encoding
  * @since 3.10.0
  */
-export declare const encodeOption: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => Option_.Option<S["Encoded"]>;
+export declare const encodeOption: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]>;
 /**
  * Encodes an `unknown` input against a schema, returning a `Result` that
- * succeeds with the encoded value or fails with a schema issue.
+ * succeeds with the encoded value or fails with a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when the input type is not statically known and encoding should return a
- * `Result` with structured issue data.
+ * Use when you do not know the input type statically and want encoding to
+ * return a `Result` with `SchemaError` failure data.
  *
  * **Details**
  *
- * For typed input use {@link encodeResult}.
+ * For values already typed as the schema's `Type` use {@link encodeResult}.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeUnknownResult} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeUnknownResult: typeof Parser.encodeUnknownResult;
+export declare function encodeUnknownResult<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError>;
 /**
  * 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.
+ * `Result` that succeeds with the encoded value or fails with a
+ * {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when typed input should be encoded into a `Result` with structured issue
- * data.
+ * Use when you already have a value typed as the schema's `Type` and want
+ * encoding to return a `Result` with `SchemaError` failure data.
  *
  * **Details**
  *
@@ -1389,28 +1434,33 @@ export declare const encodeUnknownResult: typeof Parser.encodeUnknownResult;
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeResult} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-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>;
+export declare const encodeResult: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError>;
 /**
  * Encodes an `unknown` input against a schema, returning a `Promise` that
- * resolves with the encoded value or rejects with a schema issue.
+ * resolves with the encoded value or rejects with a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when integrating unknown input serialization with Promise-based APIs.
+ * Use when you need encoding of unknown input to return a JavaScript `Promise`
+ * that rejects with `SchemaError`.
  *
  * **Details**
  *
- * For typed input use {@link encodePromise}.
+ * For values already typed as the schema's `Type` use {@link encodePromise}.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeUnknownPromise} for the adapter that rejects with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 3.10.0
  */
-export declare const encodeUnknownPromise: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: unknown, options?: AST.ParseOptions) => Promise<S["Encoded"]>;
+export declare function encodeUnknownPromise<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.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
@@ -1418,7 +1468,8 @@ export declare const encodeUnknownPromise: <S extends Encoder<unknown>>(schema:
  *
  * **When to use**
  *
- * Use when integrating typed input serialization with Promise-based APIs.
+ * Use when you already have a value typed as the schema's `Type` and need
+ * encoding to return a JavaScript `Promise` that rejects with `SchemaError`.
  *
  * **Details**
  *
@@ -1426,39 +1477,43 @@ export declare const encodeUnknownPromise: <S extends Encoder<unknown>>(schema:
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodePromise} for the adapter that rejects with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 3.10.0
  */
-export declare const encodePromise: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => Promise<S["Encoded"]>;
+export declare const encodePromise: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]>;
 /**
  * Encodes an `unknown` input against a schema synchronously, throwing a
  * {@link SchemaError} on failure.
  *
  * **When to use**
  *
- * Use when serializing unknown data at a boundary and treating schema
- * mismatches as unrecoverable errors.
+ * Use when you need to serialize unknown data at a synchronous boundary and
+ * want schema mismatches to throw `SchemaError`.
  *
  * **Details**
  *
  * For non-throwing alternatives see {@link encodeUnknownOption},
- * {@link encodeUnknownExit}, or {@link encodeUnknownEffect}. For typed input
- * use {@link encodeSync}.
+ * {@link encodeUnknownExit}, or {@link encodeUnknownEffect}. For values
+ * already typed as the schema's `Type` use {@link encodeSync}.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
+ *
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeUnknownSync: typeof Parser.encodeUnknownSync;
+export declare function encodeUnknownSync<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"];
 /**
  * Encodes a typed input (the schema's `Type`) against a schema synchronously,
  * throwing a {@link SchemaError} on failure.
  *
  * **When to use**
  *
- * Use when typed input should be encoded synchronously and schema mismatches
- * should throw.
+ * Use when you already have a value typed as the schema's `Type` and want
+ * schema mismatches to throw `SchemaError` synchronously.
  *
  * **Details**
  *
@@ -1466,10 +1521,12 @@ export declare const encodeUnknownSync: typeof Parser.encodeUnknownSync;
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
+ *
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeSync: <S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) => (input: S["Type"], options?: AST.ParseOptions) => S["Encoded"];
+export declare const encodeSync: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => S["Encoded"];
 /**
  * Creates a schema from an AST (Abstract Syntax Tree) node.
  *
@@ -1520,9 +1577,7 @@ export declare function asClass<S extends Top>(schema: S): S & {
  */
 export declare function isSchema(u: unknown): u is Top;
 /**
- * Companion type for an exact optional struct key. The key may be absent, but
- * when present must match the wrapped schema (no implicit `undefined`).
- * Produced by {@link optionalKey}.
+ * Type-level representation returned by {@link optionalKey}.
  *
  * @category models
  * @since 4.0.0
@@ -1574,8 +1629,7 @@ interface requiredKeyLambda extends Lambda {
  */
 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}.
+ * Type-level representation returned by {@link optional}.
  *
  * @category models
  * @since 3.10.0
@@ -1638,8 +1692,7 @@ interface requiredLambda extends Lambda {
  */
 export declare const required: requiredLambda;
 /**
- * Companion type for a mutable struct key. The key's property is writable.
- * Produced by {@link mutableKey}.
+ * Type-level representation returned by {@link mutableKey}.
  *
  * @category models
  * @since 4.0.0
@@ -1676,8 +1729,7 @@ interface readonlyKeyLambda extends Lambda {
  */
 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}.
+ * Type-level representation returned by {@link toType}.
  *
  * @category transforming
  * @since 4.0.0
@@ -1697,13 +1749,12 @@ interface toTypeLambda extends Lambda {
  */
 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}.
+ * Type-level representation returned 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"]> {
+export interface toEncoded<S extends Top> extends Bottom<S["Encoded"], S["Encoded"], never, never, SchemaAST.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"]> {
 }
 interface toEncodedLambda extends Lambda {
     <S extends Top>(self: S): toEncoded<S>;
@@ -1719,13 +1770,12 @@ interface toEncodedLambda extends Lambda {
 export declare const toEncoded: toEncodedLambda;
 declare const FlipTypeId = "~effect/Schema/flip";
 /**
- * Schema type representing a flipped schema where `Type` and `Encoded` are
- * swapped. Produced by {@link flip}.
+ * Type-level representation returned 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"]> {
+export interface flip<S extends Top> extends Bottom<S["Encoded"], S["Type"], S["EncodingServices"], S["DecodingServices"], SchemaAST.AST, flip<S>, S["Encoded"], S["Encoded"], ReadonlyArray<Top>, S["Encoded"], S["~encoded.mutability"], S["~encoded.optionality"], ConstructorDefault, S["~type.mutability"], S["~type.optionality"]> {
     readonly [FlipTypeId]: typeof FlipTypeId;
     readonly schema: S;
 }
@@ -1755,15 +1805,14 @@ export interface flip<S extends Top> extends Bottom<S["Encoded"], S["Type"], S["
  */
 export declare function flip<S extends Top>(schema: S): S extends flip<infer F> ? F["Rebuild"] : flip<S>;
 /**
- * Represents a schema for a single literal value.
+ * Type-level representation returned by {@link Literal}.
  *
- * @see {@link Literal} for the constructor function.
  * @category models
  * @since 3.10.0
  */
-export interface Literal<L extends AST.LiteralValue> extends Bottom<L, L, never, never, AST.Literal, Literal<L>> {
+export interface Literal<L extends SchemaAST.LiteralValue> extends Bottom<L, L, never, never, SchemaAST.Literal, Literal<L>> {
     readonly literal: L;
-    transform<L2 extends AST.LiteralValue>(to: L2): decodeTo<Literal<L2>, Literal<L>>;
+    transform<L2 extends SchemaAST.LiteralValue>(to: L2): decodeTo<Literal<L2>, Literal<L>>;
 }
 /**
  * Creates a schema for a single literal value (string, number, bigint, boolean, or null).
@@ -1783,7 +1832,7 @@ export interface Literal<L extends AST.LiteralValue> extends Bottom<L, L, never,
  * @category constructors
  * @since 3.10.0
  */
-export declare function Literal<L extends AST.LiteralValue>(literal: L): Literal<L>;
+export declare function Literal<L extends SchemaAST.LiteralValue>(literal: L): Literal<L>;
 /**
  * Namespace for {@link TemplateLiteral} helper types.
  *
@@ -1837,20 +1886,23 @@ export declare namespace TemplateLiteral {
     type Encoded<Parts> = Parts extends readonly [...infer Init, infer Last] ? AppendType<Encoded<Init>, Last> : ``;
 }
 /**
- * Represents a schema that validates strings matching a template literal pattern.
- * The encoded type is a string formed by concatenating the parts.
+ * Type-level representation returned by {@link TemplateLiteral}.
  *
- * @see {@link TemplateLiteral} for the constructor function.
  * @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>> {
+export interface TemplateLiteral<Parts extends TemplateLiteral.Parts> extends Bottom<TemplateLiteral.Encoded<Parts>, TemplateLiteral.Encoded<Parts>, never, never, SchemaAST.TemplateLiteral, TemplateLiteral<Parts>> {
     readonly parts: Parts;
 }
 /**
  * Creates a schema that validates strings matching a template literal pattern. Each part can be
  * a literal string/number/bigint or a schema whose encoded type is a string, number, or bigint.
  *
+ * **When to use**
+ *
+ * Use when the decoded value should remain the matched string and you do not
+ * need the individual template parts parsed into a tuple.
+ *
  * **Example** (URL path pattern)
  *
  * ```ts
@@ -1888,14 +1940,12 @@ export declare namespace TemplateLiteralParser {
     ] : [];
 }
 /**
- * Represents a schema that validates strings matching a template literal pattern and decodes
- * them into a tuple of typed values, one per schema part.
+ * Type-level representation returned by {@link TemplateLiteralParser}.
  *
- * @see {@link TemplateLiteralParser} for the constructor function.
  * @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>> {
+export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> extends Bottom<TemplateLiteralParser.Type<Parts>, TemplateLiteral.Encoded<Parts>, never, never, SchemaAST.Arrays, TemplateLiteralParser<Parts>> {
     readonly parts: Parts;
 }
 /**
@@ -1926,16 +1976,14 @@ export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> exte
  */
 export declare function TemplateLiteralParser<const Parts extends TemplateLiteral.Parts>(parts: Parts): TemplateLiteralParser<Parts>;
 /**
- * Represents a schema derived from a TypeScript enum object or an enum-like
- * `as const` object, accepting any of its values.
+ * Type-level representation returned by {@link Enum}.
  *
- * @see {@link Enum} for the constructor function.
  * @category models
  * @since 4.0.0
  */
 export interface Enum<A extends {
     [x: string]: string | number;
-}> extends Bottom<A[keyof A], A[keyof A], never, never, AST.Enum, Enum<A>> {
+}> extends Bottom<A[keyof A], A[keyof A], never, never, SchemaAST.Enum, Enum<A>> {
     readonly enums: A;
 }
 /**
@@ -1962,13 +2010,12 @@ export declare function Enum<A extends {
     [x: string]: string | number;
 }>(enums: A): Enum<A>;
 /**
- * Schema for the `never` type. Always fails validation.
+ * Type-level representation of {@link Never}.
  *
- * @see {@link Never} for the schema value.
  * @category models
  * @since 3.10.0
  */
-export interface Never extends Bottom<never, never, never, never, AST.Never, Never> {
+export interface Never extends Bottom<never, never, never, never, SchemaAST.Never, Never> {
 }
 /**
  * Schema for the `never` type. Always fails validation — no value satisfies it.
@@ -1978,13 +2025,12 @@ export interface Never extends Bottom<never, never, never, never, AST.Never, Nev
  */
 export declare const Never: Never;
 /**
- * Schema for the `any` type. Accepts any value without validation.
+ * Type-level representation of {@link Any}.
  *
- * @see {@link Any} for the schema value.
  * @category models
  * @since 3.10.0
  */
-export interface Any extends Bottom<any, any, never, never, AST.Any, Any> {
+export interface Any extends Bottom<any, any, never, never, SchemaAST.Any, Any> {
 }
 /**
  * Schema for the `any` type. Accepts any value without validation.
@@ -1995,30 +2041,33 @@ export interface Any extends Bottom<any, any, never, never, AST.Any, Any> {
  */
 export declare const Any: Any;
 /**
- * Schema for the `unknown` type. Accepts any value without validation.
+ * Type-level representation of {@link Unknown}.
  *
- * @see {@link Unknown} for the schema value.
  * @category models
  * @since 3.10.0
  */
-export interface Unknown extends Bottom<unknown, unknown, never, never, AST.Unknown, Unknown> {
+export interface Unknown extends Bottom<unknown, unknown, never, never, SchemaAST.Unknown, Unknown> {
 }
 /**
  * Schema for the `unknown` type. Accepts any value without validation.
  *
+ * **When to use**
+ *
+ * Use as a top schema when you need to accept any input while preserving
+ * TypeScript's `unknown` safety at use sites.
+ *
  * @see {@link Any} for the `any` variant.
  * @category schemas
  * @since 3.10.0
  */
 export declare const Unknown: Unknown;
 /**
- * Schema for the `null` literal. Validates that the input is strictly `null`.
+ * Type-level representation of {@link Null}.
  *
- * @see {@link Null} for the schema value.
  * @category models
  * @since 3.10.0
  */
-export interface Null extends Bottom<null, null, never, never, AST.Null, Null> {
+export interface Null extends Bottom<null, null, never, never, SchemaAST.Null, Null> {
 }
 /**
  * Schema for the `null` literal. Validates that the input is strictly `null`.
@@ -2029,13 +2078,12 @@ export interface Null extends Bottom<null, null, never, never, AST.Null, Null> {
  */
 export declare const Null: Null;
 /**
- * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.
+ * Type-level representation of {@link Undefined}.
  *
- * @see {@link Undefined} for the schema value.
  * @category models
  * @since 3.10.0
  */
-export interface Undefined extends Bottom<undefined, undefined, never, never, AST.Undefined, Undefined> {
+export interface Undefined extends Bottom<undefined, undefined, never, never, SchemaAST.Undefined, Undefined> {
 }
 /**
  * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.
@@ -2046,13 +2094,12 @@ export interface Undefined extends Bottom<undefined, undefined, never, never, AS
  */
 export declare const Undefined: Undefined;
 /**
- * Schema for `string` values.
+ * Type-level representation of {@link String}.
  *
- * @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> {
+export interface String extends Bottom<string, string, never, never, SchemaAST.String, String> {
 }
 /**
  * Schema for `string` values. Validates that the input is `typeof` `"string"`.
@@ -2062,13 +2109,12 @@ export interface String extends Bottom<string, string, never, never, AST.String,
  */
 export declare const String: String;
 /**
- * Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.
+ * Type-level representation of {@link Number}.
  *
- * @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> {
+export interface Number extends Bottom<number, number, never, never, SchemaAST.Number, Number> {
 }
 /**
  * Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.
@@ -2086,13 +2132,12 @@ export interface Number extends Bottom<number, number, never, never, AST.Number,
  */
 export declare const Number: Number;
 /**
- * Schema for `boolean` values.
+ * Type-level representation of {@link Boolean}.
  *
- * @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> {
+export interface Boolean extends Bottom<boolean, boolean, never, never, SchemaAST.Boolean, Boolean> {
 }
 /**
  * Schema for `boolean` values. Validates that the input is `typeof` `"boolean"`.
@@ -2103,18 +2148,17 @@ export interface Boolean extends Bottom<boolean, boolean, never, never, AST.Bool
  *
  * @see {@link BooleanFromBit} for a schema that decodes bit literals `0` or `1` into a boolean
  *
- * @category Boolean
+ * @category boolean
  * @since 4.0.0
  */
 export declare const Boolean: Boolean;
 /**
- * Schema for `symbol` values.
+ * Type-level representation of {@link Symbol}.
  *
- * @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> {
+export interface Symbol extends Bottom<symbol, symbol, never, never, SchemaAST.Symbol, Symbol> {
 }
 /**
  * Schema for `symbol` values. Validates that the input is `typeof` `"symbol"`.
@@ -2125,13 +2169,12 @@ export interface Symbol extends Bottom<symbol, symbol, never, never, AST.Symbol,
  */
 export declare const Symbol: Symbol;
 /**
- * Schema for `bigint` values.
+ * Type-level representation of {@link BigInt}.
  *
- * @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> {
+export interface BigInt extends Bottom<bigint, bigint, never, never, SchemaAST.BigInt, BigInt> {
 }
 /**
  * Schema for `bigint` values. Validates that the input is `typeof` `"bigint"`.
@@ -2148,13 +2191,12 @@ export interface BigInt extends Bottom<bigint, bigint, never, never, AST.BigInt,
  */
 export declare const BigInt: BigInt;
 /**
- * Schema for the `void` type.
+ * Type-level representation of {@link Void}.
  *
- * @see {@link Void} for the schema value.
  * @category models
  * @since 3.10.0
  */
-export interface Void extends Bottom<void, void, never, never, AST.Void, Void> {
+export interface Void extends Bottom<void, void, never, never, SchemaAST.Void, Void> {
 }
 /**
  * Schema for the `void` type. Accepts `undefined` as the encoded value.
@@ -2164,13 +2206,12 @@ export interface Void extends Bottom<void, void, never, never, AST.Void, Void> {
  */
 export declare const Void: Void;
 /**
- * Schema for the `object` type keyword.
+ * Type-level representation of {@link ObjectKeyword}.
  *
- * @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> {
+export interface ObjectKeyword extends Bottom<object, object, never, never, SchemaAST.ObjectKeyword, ObjectKeyword> {
 }
 /**
  * Schema for the `object` type. Validates that the input is a non-null object or function
@@ -2181,13 +2222,12 @@ export interface ObjectKeyword extends Bottom<object, object, never, never, AST.
  */
 export declare const ObjectKeyword: ObjectKeyword;
 /**
- * Represents a schema for a specific unique symbol.
+ * Type-level representation returned by {@link UniqueSymbol}.
  *
- * @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>> {
+export interface UniqueSymbol<sym extends symbol> extends Bottom<sym, sym, never, never, SchemaAST.UniqueSymbol, UniqueSymbol<sym>> {
 }
 /**
  * Creates a schema for a specific symbol. Only that exact symbol satisfies the schema.
@@ -2362,18 +2402,12 @@ export declare namespace Struct {
     type MakeIn<F extends Fields> = Simplify<MakeIn_<F>>;
 }
 /**
- * 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.
+ * Type-level representation returned by {@link Struct}.
  *
  * @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>> {
+export interface Struct<Fields extends Struct.Fields> extends Bottom<Struct.Type<Fields>, Struct.Encoded<Fields>, Struct.DecodingServices<Fields>, Struct.EncodingServices<Fields>, SchemaAST.Objects, Struct<Fields>, Struct.MakeIn<Fields>, Struct.Iso<Fields>> {
     /**
      * The field definitions of this struct. Spread them into a new struct to
      * reuse fields across schemas.
@@ -2459,8 +2493,8 @@ interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
  *
  * **When to use**
  *
- * Use to add the same fields to an existing struct or to every struct member of
- * a union.
+ * Use to add the same fields to an existing struct or every struct member of a
+ * union.
  *
  * **Details**
  *
@@ -2483,8 +2517,7 @@ interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
  */
 export declare function fieldsAssign<const NewFields extends Struct.Fields>(fields: NewFields): fieldsAssign<NewFields>;
 /**
- * Schema type for a struct with renamed encoded keys. Produced by
- * {@link encodeKeys}.
+ * Type-level representation returned by {@link encodeKeys}.
  *
  * @category transforming
  * @since 4.0.0
@@ -2715,21 +2748,12 @@ export declare namespace Record {
     };
 }
 /**
- * Companion type for a key-value record (map) with a typed key and value schema.
- * Produced by {@link Record}.
- *
- * **When to use**
- *
- * Use as the concrete schema type returned by `Record` when an API needs to
- * accept or return a record schema with typed property keys and values.
- *
- * @see {@link Record} for constructing record schemas
- * @see {@link StructWithRest} for combining fixed struct fields with record index signatures
+ * Type-level representation returned 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>> {
+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>, SchemaAST.Objects, $Record<Key, Value>, Simplify<Record.MakeIn<Key, Value>>, Record.Iso<Key, Value>> {
     readonly key: Key;
     readonly value: Value;
 }
@@ -2779,7 +2803,7 @@ export declare namespace StructWithRest {
      * @since 4.0.0
      */
     type Objects = Top & {
-        readonly ast: AST.Objects;
+        readonly ast: SchemaAST.Objects;
     };
     /**
      * Readonly list of record schemas that provide the additional index signatures
@@ -2790,6 +2814,9 @@ export declare namespace StructWithRest {
      */
     type Records = ReadonlyArray<$Record<Record.Key, Top>>;
     type MergeTuple<T extends ReadonlyArray<unknown>> = T extends readonly [infer Head, ...infer Tail] ? Head & MergeTuple<Tail> : {};
+    type Intersect<S extends Objects, Records extends StructWithRest.Records, Side extends "Type" | "Iso" | "Encoded" | "~type.make"> = S[Side] & MergeTuple<{
+        readonly [K in keyof Records]: Records[K][Side];
+    }>;
     /**
      * Computes the decoded type for `StructWithRest` by intersecting the base object
      * schema's decoded `Type` with the decoded types of all rest record schemas.
@@ -2797,9 +2824,7 @@ export declare namespace StructWithRest {
      * @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"];
-    }>;
+    type Type<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "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.
@@ -2807,9 +2832,7 @@ export declare namespace StructWithRest {
      * @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"];
-    }>;
+    type Iso<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "Iso">;
     /**
      * Computes the encoded type for `StructWithRest` by intersecting the base object
      * schema's encoded type with the encoded types of all rest record schemas.
@@ -2817,9 +2840,19 @@ export declare namespace StructWithRest {
      * @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"];
-    }>;
+    type Encoded<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "Encoded">;
+    /**
+     * 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> = Intersect<S, Records, "~type.make">;
+    type Services<S extends Objects, Records extends StructWithRest.Records, Side extends "DecodingServices" | "EncodingServices"> = S[Side] | {
+        [K in keyof Records]: Records[K][Side];
+    }[number];
     /**
      * Union of the decoding service requirements of the base object schema and all
      * rest record schemas.
@@ -2827,9 +2860,7 @@ export declare namespace StructWithRest {
      * @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];
+    type DecodingServices<S extends Objects, Records extends StructWithRest.Records> = Services<S, Records, "DecodingServices">;
     /**
      * Union of the encoding service requirements of the base object schema and all
      * rest record schemas.
@@ -2837,37 +2868,32 @@ export declare namespace StructWithRest {
      * @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"];
+    type EncodingServices<S extends Objects, Records extends StructWithRest.Records> = Services<S, Records, "EncodingServices">;
+    type IncompatibleKeys<A, B, OK extends (keyof A & keyof B) = Extract<keyof A, keyof B>> = {
+        [K in OK]: Required<Pick<A, K>>[K] extends B[K] ? never : K;
+    }[OK];
+    type IncompatibleSideKeys<S extends Objects, Records extends StructWithRest.Records, Side extends "Type" | "Encoded" | "Iso" | "~type.make"> = {
+        [I in keyof Records]: Records[I][Side] extends object ? IncompatibleKeys<S[Side], Records[I][Side]> : never;
     }[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.
+     * Validates that the records are compatible with the struct.
      *
      * @category utility types
      * @since 4.0.0
      */
-    type MakeIn<S extends Objects, Records extends StructWithRest.Records> = S["~type.make"] & MergeTuple<{
-        readonly [K in keyof Records]: Records[K]["~type.make"];
-    }>;
+    type ValidateRecords<S extends Objects, Records extends StructWithRest.Records> = [
+        IncompatibleSideKeys<S, Records, "Type"> | IncompatibleSideKeys<S, Records, "Encoded"> | IncompatibleSideKeys<S, Records, "Iso"> | IncompatibleSideKeys<S, Records, "~type.make">
+    ] extends [never] ? unknown : {
+        "incompatible index signatures": IncompatibleSideKeys<S, Records, "Type"> | IncompatibleSideKeys<S, Records, "Encoded"> | IncompatibleSideKeys<S, Records, "Iso"> | IncompatibleSideKeys<S, Records, "~type.make">;
+    };
 }
 /**
- * Companion type for a struct combined with one or more record schemas. Produced
- * by {@link StructWithRest}.
- *
- * **When to use**
- *
- * Use as the schema type when generic code needs to retain the base struct
- * schema and all rest record schemas.
- *
- * @see {@link StructWithRest} for constructing this schema type
- * @see {@link Record} for constructing record schemas used as rest index signatures
+ * Type-level representation returned 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>>> {
+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>, SchemaAST.Objects, StructWithRest<S, Records>, Simplify<StructWithRest.MakeIn<S, Records>>, Simplify<StructWithRest.Iso<S, Records>>> {
     readonly schema: S;
     readonly records: Records;
 }
@@ -2882,17 +2908,17 @@ export interface StructWithRest<S extends StructWithRest.Objects, Records extend
  *
  * const schema = Schema.StructWithRest(
  *   Schema.Struct({ id: Schema.Number }),
- *   [Schema.Record(Schema.String, Schema.String)]
+ *   [Schema.Record(Schema.String, Schema.Number)]
  * )
  *
- * // { readonly id: number } & { readonly [x: string]: string }
+ * // { readonly id: number, readonly [x: string]: number }
  * type T = typeof schema.Type
  * ```
  *
  * @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>;
+export declare function StructWithRest<const S extends StructWithRest.Objects, const Records extends StructWithRest.Records>(schema: S, records: Records & StructWithRest.ValidateRecords<S, Records>): StructWithRest<S, Records>;
 /**
  * Namespace for `Tuple` type utilities.
  *
@@ -2998,12 +3024,12 @@ export declare namespace Tuple {
     type MakeIn<E extends Elements> = MakeIn_<E>;
 }
 /**
- * Companion type for a fixed-length tuple. Produced by {@link Tuple}.
+ * Type-level representation returned by {@link Tuple}.
  *
  * @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>> {
+export interface Tuple<Elements extends Tuple.Elements> extends Bottom<Tuple.Type<Elements>, Tuple.Encoded<Elements>, Tuple.DecodingServices<Elements>, Tuple.EncodingServices<Elements>, SchemaAST.Arrays, Tuple<Elements>, Tuple.MakeIn<Elements>, Tuple.Iso<Elements>> {
     readonly elements: Elements;
     /**
      * Returns a new tuple with the elements modified by the provided function.
@@ -3067,7 +3093,7 @@ export declare namespace TupleWithRest {
     type TupleType = Top & {
         readonly Type: ReadonlyArray<unknown>;
         readonly Encoded: ReadonlyArray<unknown>;
-        readonly ast: AST.Arrays;
+        readonly ast: SchemaAST.Arrays;
         readonly "~type.make": ReadonlyArray<unknown>;
         readonly "Iso": ReadonlyArray<unknown>;
     };
@@ -3161,13 +3187,12 @@ export declare namespace TupleWithRest {
     ] : M;
 }
 /**
- * Companion type for a tuple with additional rest elements. Produced by
- * {@link TupleWithRest}.
+ * Type-level representation returned 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>> {
+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"], SchemaAST.Arrays, TupleWithRest<S, Rest>, TupleWithRest.MakeIn<S["~type.make"], Rest>, TupleWithRest.Iso<S["Iso"], Rest>> {
     readonly schema: S;
     readonly rest: Rest;
 }
@@ -3203,23 +3228,12 @@ export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends T
  */
 export declare function TupleWithRest<S extends Tuple<Tuple.Elements>, const Rest extends TupleWithRest.Rest>(schema: S, rest: Rest): TupleWithRest<S, Rest>;
 /**
- * Schema interface produced by `Schema.Array` for readonly arrays.
- *
- * **When to use**
- *
- * Use as the public companion type returned by `Schema.Array` when you need to
- * refer to a readonly array schema built from an element schema.
- *
- * **Details**
- *
- * The decoded type is `ReadonlyArray<S["Type"]>`, the encoded type is
- * `ReadonlyArray<S["Encoded"]>`, and the element schema is available as
- * `value`.
+ * Type-level representation returned by {@link Array}.
  *
  * @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"]>> {
+export interface $Array<S extends Top> extends Bottom<ReadonlyArray<S["Type"]>, ReadonlyArray<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"], SchemaAST.Arrays, $Array<S>, ReadonlyArray<S["~type.make"]>, ReadonlyArray<S["Iso"]>> {
     readonly value: S;
 }
 interface ArrayLambda extends Lambda {
@@ -3252,18 +3266,12 @@ export {
  */
 ArraySchema as Array };
 /**
- * Companion type for a non-empty `ReadonlyArray`. Produced by {@link NonEmptyArray}.
- *
- * **Details**
- *
- * The decoded type is `readonly [S["Type"], ...Array<S["Type"]>]`, the encoded type is
- * `readonly [S["Encoded"], ...Array<S["Encoded"]>]`, and the element schema is available as
- * `value`.
+ * Type-level representation returned by {@link NonEmptyArray}.
  *
  * @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"]>]> {
+export interface NonEmptyArray<S extends Top> extends Bottom<readonly [S["Type"], ...Array<S["Type"]>], readonly [S["Encoded"], ...Array<S["Encoded"]>], S["DecodingServices"], S["EncodingServices"], SchemaAST.Arrays, NonEmptyArray<S>, readonly [S["~type.make"], ...Array<S["~type.make"]>], readonly [S["Iso"], ...Array<S["Iso"]>]> {
     readonly value: S;
 }
 interface NonEmptyArrayLambda extends Lambda {
@@ -3290,20 +3298,7 @@ interface NonEmptyArrayLambda extends Lambda {
  */
 export declare const NonEmptyArray: NonEmptyArrayLambda;
 /**
- * Schema interface returned by `ArrayEnsure`, which normalizes a single item or
- * an array of items into a readonly array.
- *
- * **When to use**
- *
- * Use as the schema type when generic code needs to retain the original item
- * schema.
- *
- * **Details**
- *
- * The schema decodes from `S` or `Schema.Array(S)` and produces
- * `ReadonlyArray<S["Type"]>`.
- *
- * @see {@link ArrayEnsure} for constructing this schema type
+ * Type-level representation returned by {@link ArrayEnsure}.
  *
  * @category constructors
  * @since 3.10.0
@@ -3339,7 +3334,7 @@ export interface ArrayEnsure<S extends Top> extends decodeTo<$Array<toType<S>>,
  */
 export declare function ArrayEnsure<S extends Top>(schema: S): ArrayEnsure<S>;
 /**
- * Companion type for an array with unique elements. Produced by {@link UniqueArray}.
+ * Type-level representation returned by {@link UniqueArray}.
  *
  * @category models
  * @since 4.0.0
@@ -3360,23 +3355,22 @@ export interface UniqueArray<S extends Top> extends $Array<S> {
  */
 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}.
+ * Type-level representation returned by {@link mutable}.
  *
  * @category transforming
  * @since 3.10.0
  */
 export interface mutable<S extends Top & {
-    readonly "ast": AST.Arrays;
+    readonly "ast": SchemaAST.Arrays;
 }> extends Bottom<Mutable<S["Type"]>, Mutable<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"], S["ast"], mutable<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"]> {
     readonly schema: S;
 }
 interface mutableLambda extends Lambda {
     <S extends Top & {
-        readonly "ast": AST.Arrays;
+        readonly "ast": SchemaAST.Arrays;
     }>(self: S): mutable<S>;
     readonly "~lambda.out": this["~lambda.in"] extends Top & {
-        readonly "ast": AST.Arrays;
+        readonly "ast": SchemaAST.Arrays;
     } ? mutable<this["~lambda.in"]> : "Error: schema not eligible for mutable";
 }
 /**
@@ -3398,7 +3392,7 @@ interface mutableLambda extends Lambda {
  */
 export declare const mutable: mutableLambda;
 /**
- * Companion type for a union of multiple schemas. Produced by {@link Union}.
+ * Type-level representation returned by {@link Union}.
  *
  * @category models
  * @since 3.10.0
@@ -3411,7 +3405,7 @@ export interface Union<Members extends ReadonlyArray<Top>> extends Bottom<{
     [K in keyof Members]: Members[K]["DecodingServices"];
 }[number], {
     [K in keyof Members]: Members[K]["EncodingServices"];
-}[number], AST.Union<{
+}[number], SchemaAST.Union<{
     [K in keyof Members]: Members[K]["ast"];
 }[number]>, Union<Members>, {
     [K in keyof Members]: Members[K]["~type.make"];
@@ -3467,13 +3461,12 @@ export declare function Union<const Members extends ReadonlyArray<Top>>(members:
     mode?: "anyOf" | "oneOf";
 }): Union<Members>;
 /**
- * Represents a union schema of multiple literal values.
+ * Type-level representation returned by {@link Literals}.
  *
- * @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>> {
+export interface Literals<L extends ReadonlyArray<SchemaAST.LiteralValue>> extends Bottom<L[number], L[number], never, never, SchemaAST.Union<SchemaAST.Literal>, Literals<L>> {
     readonly literals: L;
     readonly members: {
         readonly [K in keyof L]: Literal<L[K]>;
@@ -3484,7 +3477,7 @@ export interface Literals<L extends ReadonlyArray<AST.LiteralValue>> extends Bot
     mapMembers<To extends ReadonlyArray<Top>>(f: (members: this["members"]) => To): Union<Simplify<Readonly<To>>>;
     pick<const L2 extends ReadonlyArray<L[number]>>(literals: L2): Literals<L2>;
     transform<const L2 extends {
-        readonly [I in keyof L]: AST.LiteralValue;
+        readonly [I in keyof L]: SchemaAST.LiteralValue;
     }>(to: L2): Union<{
         [I in keyof L]: decodeTo<Literal<L2[I]>, Literal<L[I]>>;
     }>;
@@ -3505,9 +3498,9 @@ export interface Literals<L extends ReadonlyArray<AST.LiteralValue>> extends Bot
  * @category constructors
  * @since 4.0.0
  */
-export declare function Literals<const L extends ReadonlyArray<AST.LiteralValue>>(literals: L): Literals<L>;
+export declare function Literals<const L extends ReadonlyArray<SchemaAST.LiteralValue>>(literals: L): Literals<L>;
 /**
- * Companion type for `S | null`. Produced by {@link NullOr}.
+ * Type-level representation returned by {@link NullOr}.
  *
  * @category models
  * @since 3.10.0
@@ -3527,7 +3520,7 @@ interface NullOrLambda extends Lambda {
  */
 export declare const NullOr: NullOrLambda;
 /**
- * Companion type for `S | undefined`. Produced by {@link UndefinedOr}.
+ * Type-level representation returned by {@link UndefinedOr}.
  *
  * @category models
  * @since 3.10.0
@@ -3547,7 +3540,7 @@ interface UndefinedOrLambda extends Lambda {
  */
 export declare const UndefinedOr: UndefinedOrLambda;
 /**
- * Companion type for `S | null | undefined`. Produced by {@link NullishOr}.
+ * Type-level representation returned by {@link NullishOr}.
  *
  * @category models
  * @since 3.10.0
@@ -3567,12 +3560,12 @@ interface NullishOrLambda extends Lambda {
  */
 export declare const NullishOr: NullishOrLambda;
 /**
- * Schema type wrapping a lazily-evaluated schema. Produced by {@link suspend}.
+ * Type-level representation returned by {@link suspend}.
  *
  * @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"]> {
+export interface suspend<S extends Top> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], SchemaAST.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"]> {
 }
 /**
  * Creates a suspended schema that defers evaluation until needed. This is
@@ -3616,10 +3609,9 @@ export declare function suspend<S extends Top>(f: () => S): suspend<S>;
  * @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"];
+export declare function check<S extends Top>(...checks: readonly [SchemaAST.Check<S["Type"]>, ...Array<SchemaAST.Check<S["Type"]>>]): (self: S) => S["Rebuild"];
 /**
- * The output type of {@link refine}, narrowing the schema's `Type` to `T` via a
- * type guard.
+ * Type-level representation returned by {@link refine}.
  *
  * @category filtering
  * @since 3.10.0
@@ -3645,15 +3637,7 @@ export interface refine<T extends S["Type"], S extends Top> extends Bottom<T, S[
 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>;
 /**
- * The output type of {@link brand}, intersecting the schema's `Type` with one or
- * more {@link Brand.Brand} tags.
- *
- * **When to use**
- *
- * Use as the schema type when generic code needs to retain the wrapped schema
- * and nominal brand type.
- *
- * @see {@link brand} for adding the brand tag to an existing schema
+ * Type-level representation returned by {@link brand}.
  *
  * @category branding
  * @since 3.10.0
@@ -3693,14 +3677,8 @@ export declare function fromBrand<A extends Brand.Brand<any>>(identifier: string
     readonly "Type": Brand.Brand.Unbranded<A>;
 }>(self: S) => brand<S["Rebuild"], Brand.Brand.Keys<A>>;
 /**
- * A schema that wraps another schema and intercepts its decoding pipeline.
- *
- * **Details**
+ * Type-level representation returned by {@link middlewareDecoding}.
  *
- * The interceptor receives the full decoding `Effect` and may replace, modify,
- * or augment it — including adding service requirements via `RD`.
- *
- * @see {@link middlewareDecoding} for the constructor
  * @category decoding
  * @since 4.0.0
  */
@@ -3732,16 +3710,10 @@ export interface middlewareDecoding<S extends Top, RD> extends Bottom<S["Type"],
  * @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>;
+export declare function middlewareDecoding<S extends Top, RD>(decode: (effect: Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, S["DecodingServices"]>, options: SchemaAST.ParseOptions) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, RD>): (schema: S) => middlewareDecoding<S, RD>;
 /**
- * A schema that wraps another schema and intercepts its encoding pipeline.
- *
- * **Details**
+ * Type-level representation returned by {@link middlewareEncoding}.
  *
- * The interceptor receives the full encoding `Effect` and may replace, modify,
- * or augment it — including adding service requirements via `RE`.
- *
- * @see {@link middlewareEncoding} for the constructor
  * @category encoding
  * @since 4.0.0
  */
@@ -3773,7 +3745,7 @@ export interface middlewareEncoding<S extends Top, RE> extends Bottom<S["Type"],
  * @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>;
+export declare function middlewareEncoding<S extends Top, RE>(encode: (effect: Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, S["EncodingServices"]>, options: SchemaAST.ParseOptions) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, RE>): (schema: S) => middlewareEncoding<S, RE>;
 /**
  * Recovers from a decoding error by providing a fallback value.
  *
@@ -3796,13 +3768,14 @@ export declare function middlewareEncoding<S extends Top, RE>(encode: (effect: E
  * @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"];
+export declare function catchDecoding<S extends Top>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue>): (self: S) => S["Rebuild"];
 /**
  * Recovers from a decoding error with a handler that may require Effect services.
  *
  * **When to use**
  *
- * Use when decoding fallback logic needs services from the Effect context.
+ * Use when you need decoding fallback logic to require services from the Effect
+ * context.
  *
  * **Details**
  *
@@ -3816,7 +3789,7 @@ export declare function catchDecoding<S extends Top>(f: (issue: Issue.Issue) =>
  * @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>;
+export declare function catchDecodingWithContext<S extends Top, R = never>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, R>): (self: S) => middlewareDecoding<S, S["DecodingServices"] | R>;
 /**
  * Recovers from an encoding error by providing a fallback value.
  *
@@ -3829,13 +3802,14 @@ export declare function catchDecodingWithContext<S extends Top, R = never>(f: (i
  * @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"];
+export declare function catchEncoding<S extends Top>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue>): (self: S) => S["Rebuild"];
 /**
  * Recovers from an encoding error with a handler that may require Effect services.
  *
  * **When to use**
  *
- * Use when encoding fallback logic needs services from the Effect context.
+ * Use when you need encoding fallback logic to require services from the Effect
+ * context.
  *
  * **Details**
  *
@@ -3849,18 +3823,10 @@ export declare function catchEncoding<S extends Top>(f: (issue: Issue.Issue) =>
  * @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>;
+export declare function catchEncodingWithContext<S extends Top, R = never>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, R>): (self: S) => middlewareEncoding<S, S["EncodingServices"] | R>;
 /**
- * Schema type produced by `decodeTo` when a custom transformation composes a
- * `From` schema with a `To` schema.
- *
- * **Details**
+ * Type-level representation returned by {@link decodeTo}.
  *
- * `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
  */
@@ -3869,14 +3835,8 @@ export interface decodeTo<To extends Top, From extends Top, RD = never, RE = nev
     readonly to: To;
 }
 /**
- * The type produced by {@link decodeTo} when called without a custom transformation (passthrough composition).
- *
- * **Details**
- *
- * Equivalent to {@link decodeTo} with `RD = never` and `RE = never`, meaning the schemas
- * are composed using their natural encoding/decoding chain.
+ * Type-level representation returned by {@link decodeTo} without a custom transformation.
  *
- * @see {@link decodeTo} for the transformation variant
  * @category transforming
  * @since 3.10.0
  */
@@ -3885,25 +3845,28 @@ export interface compose<To extends Top, From extends Top> extends decodeTo<To,
 /**
  * Creates a schema that transforms from a source schema to a target schema.
  *
+ * **When to use**
+ *
+ * Use when decoding should change the schema's decoded type or encoded shape,
+ * with an optional custom bidirectional transformation.
+ *
  * **Details**
  *
- * This is a curried function: call it with the target schema `to` (and optionally a transformation),
- * then call the returned function with the source schema `from`. The resulting schema decodes from
- * `From["Encoded"]` to `To["Type"]` and encodes from `To["Type"]` back to `From["Encoded"]`.
+ * Call it with the target schema `to` and then pipe the source schema `from`
+ * into the returned function. The resulting schema decodes from
+ * `From["Encoded"]` to `To["Type"]` and encodes from `To["Type"]` back to
+ * `From["Encoded"]`.
  *
- * Key guarantees:
- * - Resulting schema has `Type = To["Type"]` and `Encoded = From["Encoded"]`
- * - When `transformation` is omitted, uses `Transformation.passthrough()` (schema composition)
- * - Combines decoding/encoding services from both `from` and `to` schemas
- * - Transformation `decode` maps `From["Type"]` → `To["Encoded"]` (used during encoding)
- * - Transformation `encode` maps `To["Encoded"]` → `From["Type"]` (used during decoding)
+ * When no transformation is provided, `SchemaTransformation.passthrough()` is
+ * used, so `From["Type"]` must already be compatible with `To["Encoded"]`.
+ * The resulting schema combines decoding and encoding services from both
+ * schemas and any custom transformation.
  *
- * Common mistakes:
- * - **Direction confusion**: Remember `to` is the target (what you decode TO), `from` is the source (what you decode FROM)
- * - **Currying**: This is curried - must use pipe: `from.pipe(Schema.decodeTo(to))`
- * - **Transformation direction**: `decode` goes `From["Type"]` → `To["Encoded"]`, `encode` goes `To["Encoded"]` → `From["Type"]`
- * - **Passthrough assumption**: Without transformation, schemas must satisfy `To["Encoded"] === From["Type"]` or use passthrough helpers
- * - **Service dependencies**: Resulting schema requires services from both schemas; use `Schema.provideService` if needed
+ * **Gotchas**
+ *
+ * In a custom transformation, `decode` maps `From["Type"]` to `To["Encoded"]`
+ * and is used on the encoding path, while `encode` maps `To["Encoded"]` to
+ * `From["Type"]` and is used on the decoding path.
  *
  * **Example** (String to Number with transformation)
  *
@@ -3929,29 +3892,32 @@ export interface compose<To extends Top, From extends Top> extends decodeTo<To,
  */
 export declare function decodeTo<To extends Top>(to: To): <From extends Top>(from: From) => compose<To, From>;
 export declare function decodeTo<To extends Top, From extends Top, RD = never, RE = never>(to: To, transformation: {
-    readonly decode: Getter.Getter<NoInfer<To["Encoded"]>, NoInfer<From["Type"]>, RD>;
-    readonly encode: Getter.Getter<NoInfer<From["Type"]>, NoInfer<To["Encoded"]>, RE>;
+    readonly decode: SchemaGetter.Getter<NoInfer<To["Encoded"]>, NoInfer<From["Type"]>, RD>;
+    readonly encode: SchemaGetter.Getter<NoInfer<From["Type"]>, NoInfer<To["Encoded"]>, RE>;
 }): (from: From) => decodeTo<To, From, RD, RE>;
 /**
  * Applies a transformation to a schema, creating a new schema with the same type but transformed encoding/decoding.
  *
+ * **When to use**
+ *
+ * Use when the decoded type stays the same and the transformation only
+ * normalizes values during encoding and decoding.
+ *
  * **Details**
  *
- * This is a curried function: call it with a transformation object, then call the returned function with a schema.
- * The resulting schema has `Type = S["Type"]` and `Encoded = S["Encoded"]`, with the transformation applied during
- * encoding and decoding operations.
+ * Call it with a transformation object and then pipe a schema into the returned
+ * function. The resulting schema keeps the same `Type` and `Encoded` types as
+ * the source schema, while applying the transformation during both decoding and
+ * encoding.
  *
- * Key guarantees:
- * - Resulting schema has `Type = S["Type"]` and `Encoded = S["Encoded"]`
- * - Uses `toType(self)` as the target schema internally (creates a schema where both Type and Encoded are `S["Type"]`)
- * - Combines decoding/encoding services from the source schema and transformation
- * - Transformation `decode` maps `S["Type"]` → `S["Type"]` (used during encoding)
- * - Transformation `encode` maps `S["Type"]` → `S["Type"]` (used during decoding)
+ * Internally this uses `toType(self)` as the target schema and combines service
+ * requirements from the source schema and the transformation.
  *
- * Common mistakes:
- * - **Currying**: This is curried - must use pipe: `schema.pipe(Schema.decode(transformation))`
- * - **Transformation direction**: `decode` and `encode` both operate on `S["Type"]` (same type, different values)
- * - **Service dependencies**: Resulting schema requires services from the source schema and transformation; use `Schema.provideService` if needed
+ * **Gotchas**
+ *
+ * Use {@link decodeTo} instead when the transformation should change the
+ * decoded type. For this helper, both transformation getters operate on
+ * `S["Type"]` values.
  *
  * **Example** (Trimming string values during encoding/decoding)
  *
@@ -3973,8 +3939,8 @@ export declare function decodeTo<To extends Top, From extends Top, RD = never, R
  * @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>;
-    readonly encode: Getter.Getter<S["Type"], S["Type"], RE>;
+    readonly decode: SchemaGetter.Getter<S["Type"], S["Type"], RD>;
+    readonly encode: SchemaGetter.Getter<S["Type"], S["Type"], RE>;
 }): (self: S) => decodeTo<toType<S>, S, RD, RE>;
 /**
  * Reverses a schema transformation so the encoded schema is supplied first.
@@ -4007,8 +3973,8 @@ export declare function decode<S extends Top, RD = never, RE = never>(transforma
  */
 export declare function encodeTo<To extends Top>(to: To): <From extends Top>(from: From) => decodeTo<From, To>;
 export declare function encodeTo<To extends Top, From extends Top, RD = never, RE = never>(to: To, transformation: {
-    readonly decode: Getter.Getter<NoInfer<From["Encoded"]>, NoInfer<To["Type"]>, RD>;
-    readonly encode: Getter.Getter<NoInfer<To["Type"]>, NoInfer<From["Encoded"]>, RE>;
+    readonly decode: SchemaGetter.Getter<NoInfer<From["Encoded"]>, NoInfer<To["Type"]>, RD>;
+    readonly encode: SchemaGetter.Getter<NoInfer<To["Type"]>, NoInfer<From["Encoded"]>, RE>;
 }): (from: From) => decodeTo<From, To, RD, RE>;
 /**
  * Applies a transformation to a schema's encoded type, creating a new schema where encoding/decoding
@@ -4036,8 +4002,8 @@ export declare function encodeTo<To extends Top, From extends Top, RD = never, R
  * @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>;
-    readonly encode: Getter.Getter<S["Encoded"], S["Encoded"], RE>;
+    readonly decode: SchemaGetter.Getter<S["Encoded"], S["Encoded"], RD>;
+    readonly encode: SchemaGetter.Getter<S["Encoded"], S["Encoded"], RE>;
 }): (self: S) => decodeTo<S, toEncoded<S>, RD, RE>;
 /**
  * Constraint used to ensure a schema field does not already have a constructor default.
@@ -4053,17 +4019,8 @@ export interface WithoutConstructorDefault {
     readonly "~type.constructor.default": "no-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.
+ * Type-level representation returned by {@link withConstructorDefault}.
  *
- * @see {@link withConstructorDefault} for the constructor
  * @category constructors
  * @since 3.10.0
  */
@@ -4099,10 +4056,8 @@ export interface withConstructorDefault<S extends Top & WithoutConstructorDefaul
  */
 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.
+ * Type-level representation returned by {@link withDecodingDefaultKey}.
  *
- * @see {@link withDecodingDefaultKey} for the constructor
  * @category decoding
  * @since 4.0.0
  */
@@ -4118,7 +4073,7 @@ export interface withDecodingDefaultKey<S extends Top, R = never> extends decode
  *   - `"passthrough"` (default): pass the value through during encoding
  *   - `"omit"`: omit the key from the encoded output
  *
- * @category models
+ * @category options
  * @since 4.0.0
  */
 export type DecodingDefaultOptions = {
@@ -4160,11 +4115,8 @@ export type DecodingDefaultOptions = {
  */
 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.
+ * Type-level representation returned by {@link withDecodingDefaultTypeKey}.
  *
- * @see {@link withDecodingDefaultTypeKey} for the constructor
  * @category decoding
  * @since 4.0.0
  */
@@ -4195,10 +4147,8 @@ export interface withDecodingDefaultTypeKey<S extends Top, R = never> extends de
  */
 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.
+ * Type-level representation returned by {@link withDecodingDefault}.
  *
- * @see {@link withDecodingDefault} for the constructor
  * @category decoding
  * @since 3.10.0
  */
@@ -4210,6 +4160,11 @@ export interface withDecodingDefault<S extends Top, R = never> extends decodeTo<
  * and provides a default `Encoded` value when the field is missing or
  * `undefined` during decoding.
  *
+ * **When to use**
+ *
+ * Use when the default is expressed in the encoded representation, before the
+ * field's decoding transformation runs.
+ *
  * **Details**
  *
  * The default value is specified in terms of the `Encoded` type (before any
@@ -4241,11 +4196,8 @@ export interface withDecodingDefault<S extends Top, R = never> extends decodeTo<
  */
 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.
+ * Type-level representation returned by {@link withDecodingDefaultType}.
  *
- * @see {@link withDecodingDefaultType} for the constructor
  * @category decoding
  * @since 4.0.0
  */
@@ -4257,6 +4209,11 @@ export interface withDecodingDefaultType<S extends Top, R = never> extends decod
  * and provides a default `Type` value when the field is missing or
  * `undefined` during decoding.
  *
+ * **When to use**
+ *
+ * Use when the default is already in the decoded representation and should not
+ * pass through the field's decoding transformation.
+ *
  * **Details**
  *
  * Unlike {@link withDecodingDefault}, the default value is specified in terms
@@ -4276,17 +4233,12 @@ export interface withDecodingDefaultType<S extends Top, R = never> extends decod
  */
 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.
+ * Type-level representation returned by {@link tag}.
  *
- * **Details**
- *
- * Used as the type of the `_tag` field in {@link TaggedStruct} and related helpers.
- *
- * @see {@link tag} for the constructor
  * @category constructors
  * @since 3.10.0
  */
-export interface tag<Tag extends AST.LiteralValue> extends withConstructorDefault<Literal<Tag>> {
+export interface tag<Tag extends SchemaAST.LiteralValue> extends withConstructorDefault<Literal<Tag>> {
 }
 /**
  * Combines a {@link Literal} schema with {@link withConstructorDefault}, making it ideal
@@ -4310,7 +4262,7 @@ export interface tag<Tag extends AST.LiteralValue> extends withConstructorDefaul
  * @category constructors
  * @since 3.10.0
  */
-export declare function tag<Tag extends AST.LiteralValue>(literal: Tag): tag<Tag>;
+export declare function tag<Tag extends SchemaAST.LiteralValue>(literal: Tag): tag<Tag>;
 /**
  * Creates a literal `_tag` schema that is omitted from encoded output.
  *
@@ -4343,15 +4295,14 @@ export declare function tag<Tag extends AST.LiteralValue>(literal: Tag): tag<Tag
  * @category constructors
  * @since 4.0.0
  */
-export declare function tagDefaultOmit<Tag extends AST.LiteralValue>(literal: Tag): withDecodingDefaultKey<tag<Tag>, never>;
+export declare function tagDefaultOmit<Tag extends SchemaAST.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}.
+ * Type-level representation returned by {@link TaggedStruct}.
  *
- * @see {@link TaggedStruct} for the constructor
  * @category models
  * @since 3.10.0
  */
-export type TaggedStruct<Tag extends AST.LiteralValue, Fields extends Struct.Fields> = Struct<Simplify<{
+export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends Struct.Fields> = Struct<Simplify<{
     readonly _tag: tag<Tag>;
 } & Fields>>;
 /**
@@ -4400,7 +4351,7 @@ export type TaggedStruct<Tag extends AST.LiteralValue, Fields extends Struct.Fie
  * @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>;
+export declare function TaggedStruct<const Tag extends SchemaAST.LiteralValue, const Fields extends Struct.Fields>(value: Tag, fields: Fields): TaggedStruct<Tag, Fields>;
 /**
  * Recursively flatten any nested Schema.Union members into a single tuple of leaf schemas.
  */
@@ -4433,9 +4384,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.
+ * Type-level representation returned by {@link toTaggedUnion}.
  *
- * @see {@link toTaggedUnion} for the constructor
  * @category combinators
  * @since 4.0.0
  */
@@ -4472,10 +4422,8 @@ export declare function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag):
     readonly Type: { readonly [K in Tag]: PropertyKey; };
 }>>(self: Union<Members>) => toTaggedUnion<Tag, Members>;
 /**
- * A union schema that exposes `cases`, `guards`, `isAnyOf`, and `match` utilities keyed by the `_tag` discriminant.
- * Produced by {@link TaggedUnion}.
+ * Type-level representation returned by {@link TaggedUnion}.
  *
- * @see {@link TaggedUnion} for the constructor
  * @category models
  * @since 4.0.0
  */
@@ -4487,7 +4435,7 @@ export interface TaggedUnion<Cases extends Record<string, Top>> extends Bottom<{
     [K in keyof Cases]: Cases[K]["DecodingServices"];
 }[keyof Cases], {
     [K in keyof Cases]: Cases[K]["EncodingServices"];
-}[keyof Cases], AST.Union<AST.Objects>, TaggedUnion<Cases>, {
+}[keyof Cases], SchemaAST.Union<SchemaAST.Objects>, TaggedUnion<Cases>, {
     [K in keyof Cases]: Cases[K]["~type.make"];
 }[keyof Cases]> {
     readonly cases: Cases;
@@ -4536,11 +4484,8 @@ export declare function TaggedUnion<const CasesByTag extends Record<string, Stru
     readonly [K in keyof CasesByTag & string]: TaggedStruct<K, CasesByTag[K]>;
 }>;
 /**
- * The interface type for schemas created by {@link Opaque}.
- * Carries the same encoded/decoded shape as `S` but replaces `Type` with `Self & Brand`,
- * making the decoded value nominally distinct.
+ * Type-level representation returned by {@link Opaque}.
  *
- * @see {@link Opaque} for the constructor
  * @category models
  * @since 4.0.0
  */
@@ -4573,9 +4518,8 @@ export interface Opaque<Self, S extends Top, Brand> extends Bottom<Self, S["Enco
  */
 export declare function Opaque<Self, Brand = {}>(): <S extends Top>(schema: S) => Opaque<Self, S, Brand> & Omit<S, keyof Top>;
 /**
- * The type produced by {@link instanceOf} — a declaration schema that validates class instances.
+ * Type-level representation returned by {@link instanceOf}.
  *
- * @see {@link instanceOf} for the constructor
  * @category models
  * @since 3.10.0
  */
@@ -4602,16 +4546,16 @@ export interface instanceOf<T, Iso = T> extends declare<T, Iso> {
  */
 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.
+ * Constructs an `SchemaAST.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: {
-    readonly decode: Getter.Getter<T, NoInfer<To["Type"]>>;
-    readonly encode: Getter.Getter<NoInfer<To["Type"]>, T>;
-}) => AST.Link;
+    readonly decode: SchemaGetter.Getter<T, NoInfer<To["Type"]>>;
+    readonly encode: SchemaGetter.Getter<NoInfer<To["Type"]>, T>;
+}) => SchemaAST.Link;
 /**
  * Creates a custom validation filter from a predicate function.
  *
@@ -4667,10 +4611,10 @@ export declare function link<T>(): <To extends Top>(encodeTo: To, transformation
  * //   at ["c"])]))
  * ```
  *
- * @category Checks Constructors
+ * @category constructors
  * @since 4.0.0
  */
-export declare const makeFilter: <T>(filter: (input: T, ast: AST.AST, options: AST.ParseOptions) => FilterOutput, annotations?: Annotations.Filter | undefined, abort?: boolean) => AST.Filter<T>;
+export declare const makeFilter: <T>(filter: (input: T, ast: SchemaAST.AST, options: SchemaAST.ParseOptions) => FilterOutput, annotations?: Annotations.Filter | undefined, abort?: boolean) => SchemaAST.Filter<T>;
 /**
  * A single failure reported by a filter predicate. Used as the element type
  * of the array arm of {@link FilterOutput}, and also accepted on its own.
@@ -4678,53 +4622,53 @@ export declare const makeFilter: <T>(filter: (input: T, ast: AST.AST, options: A
  * **Details**
  *
  * - `string`: failure with that string as the message. Produces an
- *   {@link Issue.InvalidValue} wrapping the input, with the string used as
+ *   {@link SchemaIssue.InvalidValue} wrapping the input, with the string used as
  *   the issue's `message` annotation.
- * - {@link Issue.Issue}: a fully-formed issue, returned as-is.
+ * - {@link SchemaIssue.Issue}: a fully-formed issue, returned as-is.
  * - `{ path, issue }`: failure attached to a nested path. `issue` is either
- *   a `string` (wrapped in an {@link Issue.InvalidValue}) or a full
- *   {@link Issue.Issue}; the result is wrapped in an {@link Issue.Pointer}
+ *   a `string` (wrapped in an {@link SchemaIssue.InvalidValue}) or a full
+ *   {@link SchemaIssue.Issue}; the result is wrapped in an {@link SchemaIssue.Pointer}
  *   at the given `path`.
  *
  * @category models
  * @since 3.10.0
  */
-export type FilterIssue = string | Issue.Issue | {
+export type FilterIssue = string | SchemaIssue.Issue | {
     readonly path: ReadonlyArray<PropertyKey>;
-    readonly issue: string | Issue.Issue;
+    readonly issue: string | SchemaIssue.Issue;
 };
 /**
  * The value a filter predicate (see {@link makeFilter}) may return.
  *
  * **Details**
  *
- * Each shape is normalized into an {@link Issue.Issue} (or `undefined` for
+ * Each shape is normalized into an {@link SchemaIssue.Issue} (or `undefined` for
  * success) before being attached to the parse result:
  *
  * - `undefined`: success. The input satisfies the filter.
  * - `true`: success. Equivalent to `undefined`, useful when the predicate is
  *   a plain boolean expression.
- * - `false`: generic failure. Produces an {@link Issue.InvalidValue} wrapping
+ * - `false`: generic failure. Produces an {@link SchemaIssue.InvalidValue} wrapping
  *   the input, with no custom message.
  * - {@link FilterIssue}: a single failure. See {@link FilterIssue} for the
- *   shapes (`string`, {@link Issue.Issue}, or `{ path, issue }`).
+ *   shapes (`string`, {@link SchemaIssue.Issue}, or `{ path, issue }`).
  * - `ReadonlyArray<FilterIssue>`: several failures reported together. An
  *   empty array is treated as success; a single-element array is equivalent
  *   to returning that element directly; otherwise the entries are grouped
- *   into an {@link Issue.Composite}.
+ *   into an {@link SchemaIssue.Composite}.
  *
  * @category models
  * @since 3.10.0
  */
 export type FilterOutput = undefined | boolean | FilterIssue | ReadonlyArray<FilterIssue>;
 /**
- * Groups multiple checks into a single {@link AST.FilterGroup}, applying
+ * Groups multiple checks into a single {@link SchemaAST.FilterGroup}, applying
  * optional shared annotations to the group as a whole.
  *
- * @category Checks Constructors
+ * @category constructors
  * @since 4.0.0
  */
-export declare function makeFilterGroup<T>(checks: readonly [AST.Check<T>, ...Array<AST.Check<T>>], annotations?: Annotations.Filter | undefined): AST.FilterGroup<T>;
+export declare function makeFilterGroup<T>(checks: readonly [SchemaAST.Check<T>, ...Array<SchemaAST.Check<T>>], annotations?: Annotations.Filter | undefined): SchemaAST.FilterGroup<T>;
 /**
  * Validates that a string has no leading or trailing whitespace.
  *
@@ -4743,7 +4687,7 @@ export declare function makeFilterGroup<T>(checks: readonly [AST.Check<T>, ...Ar
  * @category String checks
  * @since 4.0.0
  */
-export declare function isTrimmed(annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isTrimmed(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that a string matches the specified regular expression pattern.
  *
@@ -4761,7 +4705,7 @@ export declare function isTrimmed(annotations?: Annotations.Filter): AST.Filter<
  * @category String checks
  * @since 4.0.0
  */
-export declare const isPattern: (regExp: globalThis.RegExp, annotations?: Annotations.Filter) => AST.Filter<string>;
+export declare const isPattern: (regExp: globalThis.RegExp, annotations?: Annotations.Filter) => SchemaAST.Filter<string>;
 /**
  * Validates that a string represents a finite number.
  *
@@ -4780,7 +4724,7 @@ export declare const isPattern: (regExp: globalThis.RegExp, annotations?: Annota
  * @category String checks
  * @since 4.0.0
  */
-export declare const isStringFinite: (annotations?: Annotations.Filter) => AST.Filter<string>;
+export declare const isStringFinite: (annotations?: Annotations.Filter) => SchemaAST.Filter<string>;
 /**
  * Validates that a string is a signed base-10 integer literal for Effect's
  * BigInt string encoding.
@@ -4798,7 +4742,7 @@ export declare const isStringFinite: (annotations?: Annotations.Filter) => AST.F
  * @category String checks
  * @since 4.0.0
  */
-export declare const isStringBigInt: (annotations?: Annotations.Filter) => AST.Filter<string>;
+export declare const isStringBigInt: (annotations?: Annotations.Filter) => SchemaAST.Filter<string>;
 /**
  * Validates that a string has the `Symbol(description)` format used by Effect's
  * symbol string encoding.
@@ -4811,7 +4755,7 @@ export declare const isStringBigInt: (annotations?: Annotations.Filter) => AST.F
  * @category String checks
  * @since 4.0.0
  */
-export declare const isStringSymbol: (annotations?: Annotations.Filter) => AST.Filter<string>;
+export declare const isStringSymbol: (annotations?: Annotations.Filter) => SchemaAST.Filter<string>;
 /**
  * Validates that a string is a valid Universally Unique Identifier (UUID).
  * Optionally specify a version (1-8) to validate against a specific UUID version.
@@ -4832,7 +4776,7 @@ export declare const isStringSymbol: (annotations?: Annotations.Filter) => AST.F
  * @category String checks
  * @since 4.0.0
  */
-export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that a string is a valid ULID (Universally Unique Lexicographically
  * Sortable Identifier).
@@ -4852,7 +4796,7 @@ export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotati
  * @category String checks
  * @since 4.0.0
  */
-export declare function isULID(annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isULID(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that a string is valid Base64 encoded data.
  *
@@ -4871,7 +4815,7 @@ export declare function isULID(annotations?: Annotations.Filter): AST.Filter<str
  * @category String checks
  * @since 4.0.0
  */
-export declare function isBase64(annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isBase64(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that a string is valid Base64URL encoded data (Base64 with URL-safe
  * characters).
@@ -4891,7 +4835,7 @@ export declare function isBase64(annotations?: Annotations.Filter): AST.Filter<s
  * @category String checks
  * @since 4.0.0
  */
-export declare function isBase64Url(annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isBase64Url(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates at runtime that a string starts with the specified literal prefix.
  *
@@ -4905,7 +4849,7 @@ export declare function isBase64Url(annotations?: Annotations.Filter): AST.Filte
  * @category String checks
  * @since 4.0.0
  */
-export declare function isStartsWith(startsWith: string, annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isStartsWith(startsWith: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates at runtime that a string ends with the specified literal suffix.
  *
@@ -4919,7 +4863,7 @@ export declare function isStartsWith(startsWith: string, annotations?: Annotatio
  * @category String checks
  * @since 4.0.0
  */
-export declare function isEndsWith(endsWith: string, annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isEndsWith(endsWith: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates at runtime that a string contains the specified literal substring.
  *
@@ -4933,7 +4877,7 @@ export declare function isEndsWith(endsWith: string, annotations?: Annotations.F
  * @category String checks
  * @since 4.0.0
  */
-export declare function isIncludes(includes: string, annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isIncludes(includes: string, annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that a string is unchanged by JavaScript's `toUpperCase()`.
  *
@@ -4946,7 +4890,7 @@ export declare function isIncludes(includes: string, annotations?: Annotations.F
  * @category String checks
  * @since 4.0.0
  */
-export declare function isUppercased(annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isUppercased(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that a string is unchanged by JavaScript's `toLowerCase()`.
  *
@@ -4959,7 +4903,7 @@ export declare function isUppercased(annotations?: Annotations.Filter): AST.Filt
  * @category String checks
  * @since 4.0.0
  */
-export declare function isLowercased(annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isLowercased(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that the first character of a string is unchanged by
  * `toUpperCase()`.
@@ -4972,7 +4916,7 @@ export declare function isLowercased(annotations?: Annotations.Filter): AST.Filt
  * @category String checks
  * @since 4.0.0
  */
-export declare function isCapitalized(annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isCapitalized(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that the first character of a string is unchanged by
  * `toLowerCase()`.
@@ -4985,7 +4929,7 @@ export declare function isCapitalized(annotations?: Annotations.Filter): AST.Fil
  * @category String checks
  * @since 4.0.0
  */
-export declare function isUncapitalized(annotations?: Annotations.Filter): AST.Filter<string>;
+export declare function isUncapitalized(annotations?: Annotations.Filter): SchemaAST.Filter<string>;
 /**
  * Validates that a number is finite (not `Infinity`, `-Infinity`, or `NaN`).
  *
@@ -5004,7 +4948,7 @@ export declare function isUncapitalized(annotations?: Annotations.Filter): AST.F
  * @category Number checks
  * @since 4.0.0
  */
-export declare function isFinite(annotations?: Annotations.Filter): AST.Filter<number>;
+export declare function isFinite(annotations?: Annotations.Filter): SchemaAST.Filter<number>;
 /**
  * Creates a greater-than (`>`) check for any ordered type from an
  * `Order.Order` instance.
@@ -5016,7 +4960,7 @@ export declare function makeIsGreaterThan<T>(options: {
     readonly order: Order.Order<T>;
     readonly annotate?: ((exclusiveMinimum: T) => Annotations.Filter) | undefined;
     readonly formatter?: Formatter<T> | undefined;
-}): (exclusiveMinimum: T, annotations?: Annotations.Filter) => AST.Filter<T>;
+}): (exclusiveMinimum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
 /**
  * Creates a greater-than-or-equal-to (`>=`) check for any ordered type from an
  * `Order.Order` instance.
@@ -5028,7 +4972,7 @@ export declare function makeIsGreaterThanOrEqualTo<T>(options: {
     readonly order: Order.Order<T>;
     readonly annotate?: ((exclusiveMinimum: T) => Annotations.Filter) | undefined;
     readonly formatter?: Formatter<T> | undefined;
-}): (minimum: T, annotations?: Annotations.Filter) => AST.Filter<T>;
+}): (minimum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
 /**
  * Creates a less-than (`<`) check for any ordered type from an `Order.Order`
  * instance.
@@ -5040,7 +4984,7 @@ export declare function makeIsLessThan<T>(options: {
     readonly order: Order.Order<T>;
     readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
     readonly formatter?: Formatter<T> | undefined;
-}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => AST.Filter<T>;
+}): (exclusiveMaximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
 /**
  * Creates a less-than-or-equal-to (`<=`) check for any ordered type from an
  * `Order.Order` instance.
@@ -5052,7 +4996,7 @@ export declare function makeIsLessThanOrEqualTo<T>(options: {
     readonly order: Order.Order<T>;
     readonly annotate?: ((exclusiveMaximum: T) => Annotations.Filter) | undefined;
     readonly formatter?: Formatter<T> | undefined;
-}): (maximum: T, annotations?: Annotations.Filter) => AST.Filter<T>;
+}): (maximum: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
 /**
  * Creates an inclusive or exclusive range check for any ordered type from an
  * `Order.Order` instance.
@@ -5074,7 +5018,7 @@ export declare function makeIsBetween<T>(deriveOptions: {
     readonly maximum: T;
     readonly exclusiveMinimum?: boolean | undefined;
     readonly exclusiveMaximum?: boolean | undefined;
-}, annotations?: Annotations.Filter) => AST.Filter<T>;
+}, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
 /**
  * Creates a divisibility check for any numeric type from a remainder function
  * and a zero value.
@@ -5087,7 +5031,7 @@ export declare function makeIsMultipleOf<T>(options: {
     readonly zero: NoInfer<T>;
     readonly annotate?: ((divisor: T) => Annotations.Filter) | undefined;
     readonly formatter?: Formatter<T> | undefined;
-}): (divisor: T, annotations?: Annotations.Filter) => AST.Filter<T>;
+}): (divisor: T, annotations?: Annotations.Filter) => SchemaAST.Filter<T>;
 /**
  * Validates that a number is greater than the specified value (exclusive).
  *
@@ -5106,7 +5050,7 @@ export declare function makeIsMultipleOf<T>(options: {
  * @category Number checks
  * @since 4.0.0
  */
-export declare const isGreaterThan: (exclusiveMinimum: number, annotations?: Annotations.Filter) => AST.Filter<number>;
+export declare const isGreaterThan: (exclusiveMinimum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
 /**
  * Validates that a number is greater than or equal to the specified value
  * (inclusive).
@@ -5125,7 +5069,7 @@ export declare const isGreaterThan: (exclusiveMinimum: number, annotations?: Ann
  * @category Number checks
  * @since 4.0.0
  */
-export declare const isGreaterThanOrEqualTo: (minimum: number, annotations?: Annotations.Filter) => AST.Filter<number>;
+export declare const isGreaterThanOrEqualTo: (minimum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
 /**
  * Validates that a number is less than the specified value (exclusive).
  *
@@ -5144,7 +5088,7 @@ export declare const isGreaterThanOrEqualTo: (minimum: number, annotations?: Ann
  * @category Number checks
  * @since 4.0.0
  */
-export declare const isLessThan: (exclusiveMaximum: number, annotations?: Annotations.Filter) => AST.Filter<number>;
+export declare const isLessThan: (exclusiveMaximum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
 /**
  * Validates that a number is less than or equal to the specified value
  * (inclusive).
@@ -5163,7 +5107,7 @@ export declare const isLessThan: (exclusiveMaximum: number, annotations?: Annota
  * @category Number checks
  * @since 4.0.0
  */
-export declare const isLessThanOrEqualTo: (maximum: number, annotations?: Annotations.Filter) => AST.Filter<number>;
+export declare const isLessThanOrEqualTo: (maximum: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
 /**
  * Validates that a number is within a specified range. The range boundaries can
  * be inclusive or exclusive based on the provided options.
@@ -5189,7 +5133,7 @@ export declare const isBetween: (options: {
     readonly maximum: number;
     readonly exclusiveMinimum?: boolean | undefined;
     readonly exclusiveMaximum?: boolean | undefined;
-}, annotations?: Annotations.Filter) => AST.Filter<number>;
+}, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
 /**
  * Validates that a number is a multiple of the specified divisor.
  *
@@ -5207,7 +5151,7 @@ export declare const isBetween: (options: {
  * @category Number checks
  * @since 4.0.0
  */
-export declare const isMultipleOf: (divisor: number, annotations?: Annotations.Filter) => AST.Filter<number>;
+export declare const isMultipleOf: (divisor: number, annotations?: Annotations.Filter) => SchemaAST.Filter<number>;
 /**
  * Validates that a number is a safe integer (within the safe integer range
  * that can be exactly represented in JavaScript).
@@ -5226,7 +5170,7 @@ export declare const isMultipleOf: (divisor: number, annotations?: Annotations.F
  * @category Integer checks
  * @since 4.0.0
  */
-export declare function isInt(annotations?: Annotations.Filter): AST.Filter<number>;
+export declare function isInt(annotations?: Annotations.Filter): SchemaAST.Filter<number>;
 /**
  * Validates that a number is a 32-bit signed integer (range: -2,147,483,648 to
  * 2,147,483,647).
@@ -5246,7 +5190,7 @@ export declare function isInt(annotations?: Annotations.Filter): AST.Filter<numb
  * @category Integer checks
  * @since 4.0.0
  */
-export declare function isInt32(annotations?: Annotations.Filter): AST.FilterGroup<number>;
+export declare function isInt32(annotations?: Annotations.Filter): SchemaAST.FilterGroup<number>;
 /**
  * Validates that a number is a 32-bit unsigned integer (range: 0 to
  * 4,294,967,295).
@@ -5266,7 +5210,7 @@ export declare function isInt32(annotations?: Annotations.Filter): AST.FilterGro
  * @category Integer checks
  * @since 4.0.0
  */
-export declare function isUint32(annotations?: Annotations.Filter): AST.FilterGroup<number>;
+export declare function isUint32(annotations?: Annotations.Filter): SchemaAST.FilterGroup<number>;
 /**
  * Validates that a Date object represents a valid date (not an invalid date
  * like `new Date("invalid")`).
@@ -5286,7 +5230,7 @@ export declare function isUint32(annotations?: Annotations.Filter): AST.FilterGr
  * @category Date checks
  * @since 4.0.0
  */
-export declare function isDateValid(annotations?: Annotations.Filter): AST.Filter<globalThis.Date>;
+export declare function isDateValid(annotations?: Annotations.Filter): SchemaAST.Filter<globalThis.Date>;
 /**
  * Validates that a Date is greater than the specified value (exclusive).
  *
@@ -5301,7 +5245,7 @@ export declare function isDateValid(annotations?: Annotations.Filter): AST.Filte
  * @category Date checks
  * @since 4.0.0
  */
-export declare const isGreaterThanDate: (exclusiveMinimum: globalThis.Date, annotations?: Annotations.Filter) => AST.Filter<globalThis.Date>;
+export declare const isGreaterThanDate: (exclusiveMinimum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
 /**
  * Validates that a Date is greater than or equal to the specified date
  * (inclusive).
@@ -5322,7 +5266,7 @@ export declare const isGreaterThanDate: (exclusiveMinimum: globalThis.Date, anno
  * @category Date checks
  * @since 4.0.0
  */
-export declare const isGreaterThanOrEqualToDate: (minimum: globalThis.Date, annotations?: Annotations.Filter) => AST.Filter<globalThis.Date>;
+export declare const isGreaterThanOrEqualToDate: (minimum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
 /**
  * Validates that a Date is less than the specified value (exclusive).
  *
@@ -5337,7 +5281,7 @@ export declare const isGreaterThanOrEqualToDate: (minimum: globalThis.Date, anno
  * @category Date checks
  * @since 4.0.0
  */
-export declare const isLessThanDate: (exclusiveMaximum: globalThis.Date, annotations?: Annotations.Filter) => AST.Filter<globalThis.Date>;
+export declare const isLessThanDate: (exclusiveMaximum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
 /**
  * Validates that a Date is less than or equal to the specified date
  * (inclusive).
@@ -5358,7 +5302,7 @@ export declare const isLessThanDate: (exclusiveMaximum: globalThis.Date, annotat
  * @category Date checks
  * @since 4.0.0
  */
-export declare const isLessThanOrEqualToDate: (maximum: globalThis.Date, annotations?: Annotations.Filter) => AST.Filter<globalThis.Date>;
+export declare const isLessThanOrEqualToDate: (maximum: globalThis.Date, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
 /**
  * Validates that a Date is within a specified range. The range boundaries can
  * be inclusive or exclusive based on the provided options.
@@ -5384,7 +5328,7 @@ export declare const isBetweenDate: (options: {
     readonly maximum: globalThis.Date;
     readonly exclusiveMinimum?: boolean | undefined;
     readonly exclusiveMaximum?: boolean | undefined;
-}, annotations?: Annotations.Filter) => AST.Filter<globalThis.Date>;
+}, annotations?: Annotations.Filter) => SchemaAST.Filter<globalThis.Date>;
 /**
  * Validates that a BigInt is greater than the specified value (exclusive).
  *
@@ -5399,7 +5343,7 @@ export declare const isBetweenDate: (options: {
  * @category BigInt checks
  * @since 4.0.0
  */
-export declare const isGreaterThanBigInt: (exclusiveMinimum: bigint, annotations?: Annotations.Filter) => AST.Filter<bigint>;
+export declare const isGreaterThanBigInt: (exclusiveMinimum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
 /**
  * Validates that a BigInt is greater than or equal to the specified value
  * (inclusive).
@@ -5415,7 +5359,7 @@ export declare const isGreaterThanBigInt: (exclusiveMinimum: bigint, annotations
  * @category BigInt checks
  * @since 4.0.0
  */
-export declare const isGreaterThanOrEqualToBigInt: (minimum: bigint, annotations?: Annotations.Filter) => AST.Filter<bigint>;
+export declare const isGreaterThanOrEqualToBigInt: (minimum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
 /**
  * Validates that a BigInt is less than the specified value (exclusive).
  *
@@ -5430,7 +5374,7 @@ export declare const isGreaterThanOrEqualToBigInt: (minimum: bigint, annotations
  * @category BigInt checks
  * @since 4.0.0
  */
-export declare const isLessThanBigInt: (exclusiveMaximum: bigint, annotations?: Annotations.Filter) => AST.Filter<bigint>;
+export declare const isLessThanBigInt: (exclusiveMaximum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
 /**
  * Validates that a BigInt is less than or equal to the specified value
  * (inclusive).
@@ -5446,7 +5390,7 @@ export declare const isLessThanBigInt: (exclusiveMaximum: bigint, annotations?:
  * @category BigInt checks
  * @since 4.0.0
  */
-export declare const isLessThanOrEqualToBigInt: (maximum: bigint, annotations?: Annotations.Filter) => AST.Filter<bigint>;
+export declare const isLessThanOrEqualToBigInt: (maximum: bigint, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
 /**
  * Validates that a BigInt is within a specified range. The range boundaries can
  * be inclusive or exclusive based on the provided options.
@@ -5467,14 +5411,14 @@ export declare const isBetweenBigInt: (options: {
     readonly maximum: bigint;
     readonly exclusiveMinimum?: boolean | undefined;
     readonly exclusiveMaximum?: boolean | undefined;
-}, annotations?: Annotations.Filter) => AST.Filter<bigint>;
+}, annotations?: Annotations.Filter) => SchemaAST.Filter<bigint>;
 /**
  * Validates that a BigDecimal is greater than the specified value (exclusive).
  *
  * @category BigDecimal checks
  * @since 4.0.0
  */
-export declare const isGreaterThanBigDecimal: (exclusiveMinimum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => AST.Filter<BigDecimal_.BigDecimal>;
+export declare const isGreaterThanBigDecimal: (exclusiveMinimum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
 /**
  * Validates that a BigDecimal is greater than or equal to the specified value
  * (inclusive).
@@ -5482,14 +5426,14 @@ export declare const isGreaterThanBigDecimal: (exclusiveMinimum: BigDecimal_.Big
  * @category BigDecimal checks
  * @since 4.0.0
  */
-export declare const isGreaterThanOrEqualToBigDecimal: (minimum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => AST.Filter<BigDecimal_.BigDecimal>;
+export declare const isGreaterThanOrEqualToBigDecimal: (minimum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
 /**
  * Validates that a BigDecimal is less than the specified value (exclusive).
  *
  * @category BigDecimal checks
  * @since 4.0.0
  */
-export declare const isLessThanBigDecimal: (exclusiveMaximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => AST.Filter<BigDecimal_.BigDecimal>;
+export declare const isLessThanBigDecimal: (exclusiveMaximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
 /**
  * Validates that a BigDecimal is less than or equal to the specified value
  * (inclusive).
@@ -5497,7 +5441,7 @@ export declare const isLessThanBigDecimal: (exclusiveMaximum: BigDecimal_.BigDec
  * @category BigDecimal checks
  * @since 4.0.0
  */
-export declare const isLessThanOrEqualToBigDecimal: (maximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => AST.Filter<BigDecimal_.BigDecimal>;
+export declare const isLessThanOrEqualToBigDecimal: (maximum: BigDecimal_.BigDecimal, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
 /**
  * Validates that a `BigDecimal` is within a specified range.
  *
@@ -5514,7 +5458,7 @@ export declare const isBetweenBigDecimal: (options: {
     readonly maximum: BigDecimal_.BigDecimal;
     readonly exclusiveMinimum?: boolean | undefined;
     readonly exclusiveMaximum?: boolean | undefined;
-}, annotations?: Annotations.Filter) => AST.Filter<BigDecimal_.BigDecimal>;
+}, annotations?: Annotations.Filter) => SchemaAST.Filter<BigDecimal_.BigDecimal>;
 /**
  * Validates that a value has at least the specified length. Works with strings
  * and arrays.
@@ -5544,7 +5488,7 @@ export declare const isBetweenBigDecimal: (options: {
  * @category Length checks
  * @since 4.0.0
  */
-export declare function isMinLength(minLength: number, annotations?: Annotations.Filter): AST.Filter<{
+export declare function isMinLength(minLength: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
     readonly length: number;
 }>;
 /**
@@ -5566,7 +5510,7 @@ export declare function isMinLength(minLength: number, annotations?: Annotations
  * @category Length checks
  * @since 4.0.0
  */
-export declare function isNonEmpty(annotations?: Annotations.Filter): AST.Filter<{
+export declare function isNonEmpty(annotations?: Annotations.Filter): SchemaAST.Filter<{
     readonly length: number;
 }>;
 /**
@@ -5589,7 +5533,7 @@ export declare function isNonEmpty(annotations?: Annotations.Filter): AST.Filter
  * @category Length checks
  * @since 4.0.0
  */
-export declare function isMaxLength(maxLength: number, annotations?: Annotations.Filter): AST.Filter<{
+export declare function isMaxLength(maxLength: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
     readonly length: number;
 }>;
 /**
@@ -5612,7 +5556,7 @@ export declare function isMaxLength(maxLength: number, annotations?: Annotations
  * @category Length checks
  * @since 4.0.0
  */
-export declare function isLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): AST.Filter<{
+export declare function isLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
     readonly length: number;
 }>;
 /**
@@ -5635,7 +5579,7 @@ export declare function isLengthBetween(minimum: number, maximum: number, annota
  * @category Size checks
  * @since 4.0.0
  */
-export declare function isMinSize(minSize: number, annotations?: Annotations.Filter): AST.Filter<{
+export declare function isMinSize(minSize: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
     readonly size: number;
 }>;
 /**
@@ -5658,7 +5602,7 @@ export declare function isMinSize(minSize: number, annotations?: Annotations.Fil
  * @category Size checks
  * @since 4.0.0
  */
-export declare function isMaxSize(maxSize: number, annotations?: Annotations.Filter): AST.Filter<{
+export declare function isMaxSize(maxSize: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
     readonly size: number;
 }>;
 /**
@@ -5681,7 +5625,7 @@ export declare function isMaxSize(maxSize: number, annotations?: Annotations.Fil
  * @category Size checks
  * @since 4.0.0
  */
-export declare function isSizeBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): AST.Filter<{
+export declare function isSizeBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<{
     readonly size: number;
 }>;
 /**
@@ -5705,7 +5649,7 @@ export declare function isSizeBetween(minimum: number, maximum: number, annotati
  * @category Object checks
  * @since 4.0.0
  */
-export declare function isMinProperties(minProperties: number, annotations?: Annotations.Filter): AST.Filter<object>;
+export declare function isMinProperties(minProperties: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
 /**
  * Validates that an object contains at most the specified number of properties.
  * This includes both string and symbol keys when counting properties.
@@ -5726,7 +5670,7 @@ export declare function isMinProperties(minProperties: number, annotations?: Ann
  * @category Object checks
  * @since 4.0.0
  */
-export declare function isMaxProperties(maxProperties: number, annotations?: Annotations.Filter): AST.Filter<object>;
+export declare function isMaxProperties(maxProperties: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
 /**
  * Validates that an object contains between `minimum` and `maximum` properties (inclusive).
  * This includes both string and symbol keys when counting properties.
@@ -5747,7 +5691,7 @@ export declare function isMaxProperties(maxProperties: number, annotations?: Ann
  * @category Object checks
  * @since 4.0.0
  */
-export declare function isPropertiesLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): AST.Filter<object>;
+export declare function isPropertiesLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
 /**
  * Validates that every own property key of an object satisfies the encoded side
  * of the provided key schema.
@@ -5764,7 +5708,7 @@ export declare function isPropertiesLengthBetween(minimum: number, maximum: numb
  * @category Object checks
  * @since 4.0.0
  */
-export declare function isPropertyNames(keySchema: Top, annotations?: Annotations.Filter): AST.Filter<object>;
+export declare function isPropertyNames(keySchema: Top, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
 /**
  * Validates that all items in an array are unique according to Effect equality.
  *
@@ -5780,12 +5724,11 @@ export declare function isPropertyNames(keySchema: Top, annotations?: Annotation
  * @category Array checks
  * @since 4.0.0
  */
-export declare function isUnique<T>(annotations?: Annotations.Filter): AST.Filter<readonly T[]>;
+export declare function isUnique<T>(annotations?: Annotations.Filter): SchemaAST.Filter<readonly T[]>;
 /**
- * Type-level representation of the `NonEmptyString` schema, which validates
- * strings with a length of at least one.
+ * Type-level representation of {@link NonEmptyString}.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export interface NonEmptyString extends String {
@@ -5795,15 +5738,14 @@ export interface NonEmptyString extends String {
  * Schema for non-empty strings. Validates that a string has at least one
  * character.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export declare const NonEmptyString: NonEmptyString;
 /**
- * Type-level representation of the `Char` schema, which validates strings whose
- * length is exactly one.
+ * Type-level representation of {@link Char}.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export interface Char extends String {
@@ -5825,26 +5767,12 @@ export interface Char extends String {
  * @see {@link NonEmptyString} for strings with length greater than zero
  * @see {@link isLengthBetween} for the underlying length check
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export declare const Char: Char;
 /**
- * Schema for the `Option<A>` type, representing an optional value that is
- * either `None` or `Some<A>`.
- *
- * **Example** (Option schema)
- *
- * ```ts
- * import { Option, Schema } from "effect"
- *
- * const schema = Schema.Option(Schema.Number)
- *
- * Schema.decodeUnknownSync(schema)(Option.some(1))
- * // => Some(1)
- * Schema.decodeUnknownSync(schema)(Option.none())
- * // => None
- * ```
+ * Type-level representation returned by {@link Option}.
  *
  * @category Option
  * @since 3.10.0
@@ -5878,8 +5806,7 @@ export type OptionIso<A extends Top> = {
  */
 export declare function Option<A extends Top>(value: A): Option<A>;
 /**
- * Type-level representation of a schema that decodes `null` as `None` and all
- * other values as `Some`.
+ * Type-level representation returned by {@link OptionFromNullOr}.
  *
  * @category Option
  * @since 3.10.0
@@ -5892,21 +5819,15 @@ export interface OptionFromNullOr<S extends Top> extends decodeTo<Option<toType<
  *
  * **Details**
  *
- * Decoding:
- * - `null` is decoded as `None`
- * - other values are decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as `null`
- * - `Some` is encoded as the value
+ * Decoding maps `null` to `None` and all other values to `Some`. Encoding maps
+ * `None` to `null` and maps `Some` to its value.
  *
  * @category Option
  * @since 3.10.0
  */
 export declare function OptionFromNullOr<S extends Top>(schema: S): OptionFromNullOr<S>;
 /**
- * Type-level representation of a schema that decodes `undefined` as `None` and
- * all other values as `Some`.
+ * Type-level representation returned by {@link OptionFromUndefinedOr}.
  *
  * @category Option
  * @since 3.10.0
@@ -5915,25 +5836,20 @@ export interface OptionFromUndefinedOr<S extends Top> extends decodeTo<Option<to
     readonly "Rebuild": OptionFromUndefinedOr<S>;
 }
 /**
- * Decodes an undefined-or value `T` to a required `Option<T>` value.
+ * Decodes a required value that may be `undefined` to a required `Option<T>`
+ * value.
  *
  * **Details**
  *
- * Decoding:
- * - `undefined` is decoded as `None`
- * - other values are decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as `undefined`
- * - `Some` is encoded as the value
+ * Decoding maps `undefined` to `None` and all other values to `Some`. Encoding
+ * maps `None` to `undefined` and maps `Some` to its value.
  *
  * @category Option
  * @since 3.10.0
  */
 export declare function OptionFromUndefinedOr<S extends Top>(schema: S): OptionFromUndefinedOr<S>;
 /**
- * Type-level representation of a schema that decodes `null` or `undefined` as
- * `None` and all other values as `Some`.
+ * Type-level representation returned by {@link OptionFromNullishOr}.
  *
  * @category Option
  * @since 3.10.0
@@ -5946,13 +5862,10 @@ export interface OptionFromNullishOr<S extends Top> extends decodeTo<Option<toTy
  *
  * **Details**
  *
- * Decoding:
- * - `null` and `undefined` are decoded as `None`
- * - other values are decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as `null` or `undefined` depending on the provided `options.onNoneEncoding` (defaults to `undefined`)
- * - `Some` is encoded as the value
+ * Decoding maps `null` and `undefined` to `None` and all other values to
+ * `Some`. Encoding maps `None` to `null` or `undefined` depending on
+ * `options.onNoneEncoding`, which defaults to `undefined`, and maps `Some` to
+ * its value.
  *
  * @category Option
  * @since 3.10.0
@@ -5961,8 +5874,7 @@ export declare function OptionFromNullishOr<S extends Top>(schema: S, options?:
     onNoneEncoding: null | undefined;
 }): OptionFromNullishOr<S>;
 /**
- * Type-level representation of a schema that decodes a missing object key as
- * `None` and a present key as `Some`.
+ * Type-level representation returned by {@link OptionFromOptionalKey}.
  *
  * @category Option
  * @since 4.0.0
@@ -5975,21 +5887,15 @@ export interface OptionFromOptionalKey<S extends Top> extends decodeTo<Option<to
  *
  * **Details**
  *
- * Decoding:
- * - a missing key is decoded as `None`
- * - a present value is decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as missing key
- * - `Some` is encoded as the value
+ * Decoding maps a missing key to `None` and a present value to `Some`.
+ * Encoding maps `None` to a missing key and maps `Some` to its value.
  *
  * @category Option
  * @since 4.0.0
  */
 export declare function OptionFromOptionalKey<S extends Top>(schema: S): OptionFromOptionalKey<S>;
 /**
- * Type-level representation of a schema that decodes a missing key or
- * `undefined` value as `None` and other present values as `Some`.
+ * Type-level representation returned by {@link OptionFromOptional}.
  *
  * @category Option
  * @since 4.0.0
@@ -5998,27 +5904,21 @@ export interface OptionFromOptional<S extends Top> extends decodeTo<Option<toTyp
     readonly "Rebuild": OptionFromOptional<S>;
 }
 /**
- * Decodes an optional or `undefined` value `A` to an required `Option<A>`
+ * Decodes an optional or `undefined` value `A` to a required `Option<A>`
  * value.
  *
  * **Details**
  *
- * Decoding:
- * - a missing key is decoded as `None`
- * - a present key with an `undefined` value is decoded as `None`
- * - all other values are decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as missing key
- * - `Some` is encoded as the value
+ * Decoding maps a missing key or a present `undefined` value to `None`, and
+ * maps all other values to `Some`. Encoding maps `None` to a missing key and
+ * maps `Some` to its value.
  *
  * @category Option
  * @since 4.0.0
  */
 export declare function OptionFromOptional<S extends Top>(schema: S): OptionFromOptional<S>;
 /**
- * Type-level representation of a schema that decodes a missing key, `undefined`,
- * or `null` as `None` and all other present values as `Some`.
+ * Type-level representation returned by {@link OptionFromOptionalNullOr}.
  *
  * @category Option
  * @since 4.0.0
@@ -6032,17 +5932,10 @@ export interface OptionFromOptionalNullOr<S extends Top> extends decodeTo<Option
  *
  * **Details**
  *
- * Decoding:
- * - a missing key is decoded as `None`
- * - a present key with an `undefined` value is decoded as `None`
- * - a present key with a `null` value is decoded as `None`
- * - all other values are decoded as `Some`
- *
- * Encoding (controlled by `options.onNoneEncoding`):
- * - `"omit"` (default): `None` is encoded as a missing key
- * - `null`: `None` is encoded as `null`
- * - `undefined`: `None` is encoded as `undefined`
- * - `Some` is always encoded as the value
+ * Decoding maps a missing key, `undefined`, or `null` to `None`, and maps all
+ * other values to `Some`. Encoding maps `Some` to its value. `None` is encoded
+ * according to `options.onNoneEncoding`: `"omit"` encodes a missing key,
+ * `null` encodes `null`, and `undefined` encodes `undefined`.
  *
  * @category Option
  * @since 4.0.0
@@ -6051,8 +5944,7 @@ export declare function OptionFromOptionalNullOr<S extends Top>(schema: S, optio
     readonly onNoneEncoding: "omit" | null | undefined;
 }): OptionFromOptionalNullOr<S>;
 /**
- * Schema for the `Result<A, E>` type, representing a computation that either
- * succeeds with `A` or fails with `E`.
+ * Type-level representation returned by {@link Result}.
  *
  * @category schemas
  * @since 4.0.0
@@ -6088,8 +5980,7 @@ export type ResultIso<A extends Top, E extends Top> = {
  */
 export declare function Result<A extends Top, E extends Top>(success: A, failure: E): Result<A, E>;
 /**
- * Schema for the `Redacted<A>` type, providing secure handling of sensitive
- * values. The inner value is hidden from error messages.
+ * Type-level representation returned by {@link Redacted}.
  *
  * @category Redacted
  * @since 3.10.0
@@ -6126,8 +6017,7 @@ export declare function Redacted<S extends Top>(value: S, options?: {
     readonly disallowJsonEncode?: boolean | undefined;
 }): Redacted<S>;
 /**
- * Type-level representation of a schema that decodes a raw value with the
- * provided schema and wraps the result in `Redacted`.
+ * Type-level representation returned by {@link RedactedFromValue}.
  *
  * @category Redacted
  * @since 4.0.0
@@ -6156,22 +6046,7 @@ export declare function RedactedFromValue<S extends Top>(value: S, options?: {
     readonly disallowEncode?: boolean | undefined;
 }): RedactedFromValue<S>;
 /**
- * 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`).
- *
- * **When to use**
- *
- * Use as the schema type when generic code needs to retain the typed failure
- * and defect schemas for a single cause reason.
- *
- * **Details**
- *
- * The `error` schema validates typed failures and the `defect` schema validates
- * unexpected defects.
- *
- * @see {@link CauseReason} for constructing this schema type
- * @see {@link CauseReasonIso} for the ISO shape of each cause reason
+ * Type-level representation returned by {@link CauseReason}.
  *
  * @category CauseReason
  * @since 4.0.0
@@ -6208,8 +6083,8 @@ export type CauseReasonIso<E extends Top, D extends Top> = {
  *
  * **When to use**
  *
- * Use to validate, transform, or serialize individual `Cause.Reason` values
- * when typed failures and unexpected defects need separate schemas.
+ * Use when serializing or decoding individual cause reasons separately from a
+ * full failure cause, with distinct schemas for typed errors and defects.
  *
  * **Details**
  *
@@ -6224,21 +6099,7 @@ export type CauseReasonIso<E extends Top, D extends Top> = {
  */
 export declare function CauseReason<E extends Top, D extends Top>(error: E, defect: D): CauseReason<E, D>;
 /**
- * Schema for `Cause` values, represented as an ordered collection of failure
- * reasons combining typed errors, defects, and interrupts.
- *
- * **When to use**
- *
- * Use as the schema type when generic code needs to retain the typed failure
- * and defect schemas for a full cause.
- *
- * **Details**
- *
- * The `error` schema validates typed failures and the `defect` schema validates
- * unexpected defects.
- *
- * @see {@link Cause} for constructing this schema type
- * @see {@link CauseIso} for the ordered array representation used by the schema ISO
+ * Type-level representation returned by {@link Cause}.
  *
  * @category Cause
  * @since 3.10.0
@@ -6287,7 +6148,7 @@ export type CauseIso<E extends Top, D extends Top> = ReadonlyArray<CauseReasonIs
  */
 export declare function Cause<E extends Top, D extends Top>(error: E, defect: D): Cause<E, D>;
 /**
- * Type-level representation of the schema for JavaScript `Error` instances.
+ * Type-level representation of {@link Error}.
  *
  * @category Error
  * @since 4.0.0
@@ -6324,8 +6185,7 @@ export declare const Error: Error;
  */
 export declare const ErrorWithStack: Error;
 /**
- * Type-level representation of the `Defect` schema, which accepts JavaScript
- * `Error` values and arbitrary unknown defect values.
+ * Type-level representation of {@link Defect}.
  *
  * @category Defect
  * @since 3.10.0
@@ -6362,8 +6222,7 @@ export declare const Defect: Defect;
  */
 export declare const DefectWithStack: Defect;
 /**
- * Schema for `Exit` values, representing either a success with value `A` or a
- * failure with a `Cause` containing typed errors and defects.
+ * Type-level representation returned by {@link Exit}.
  *
  * @category Exit
  * @since 3.10.0
@@ -6396,22 +6255,17 @@ export type ExitIso<A extends Top, E extends Top, D extends Top> = {
  * Creates a schema for `Exit` values using schemas for the success value, typed
  * failure, and unexpected defect channels.
  *
+ * **When to use**
+ *
+ * Use when serializing or validating an effect outcome where success, typed
+ * failure, and defects each need their own schema.
+ *
  * @category Exit
  * @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>;
 /**
- * Type-level representation of a `ReadonlyMap` schema whose keys and values are
- * validated by the provided schemas.
- *
- * **When to use**
- *
- * Use as a type annotation for a `ReadonlyMap` schema when exposing or returning
- * the schema while preserving its key schema, value schema, and ISO
- * representation.
- *
- * @see {@link ReadonlyMap} for constructing this schema type from key and value schemas
- * @see {@link ReadonlyMapIso} for the readonly tuple-array ISO representation used by this schema
+ * Type-level representation returned by {@link ReadonlyMap}.
  *
  * @category ReadonlyMap
  * @since 4.0.0
@@ -6438,8 +6292,7 @@ export type ReadonlyMapIso<Key extends Top, Value extends Top> = ReadonlyArray<r
  */
 export declare function ReadonlyMap<Key extends Top, Value extends Top>(key: Key, value: Value): $ReadonlyMap<Key, Value>;
 /**
- * Schema for an Effect `HashMap` where keys and values must conform to the
- * provided schemas.
+ * Type-level representation returned by {@link HashMap}.
  *
  * @category HashMap
  * @since 3.10.0
@@ -6465,16 +6318,7 @@ export type HashMapIso<Key extends Top, Value extends Top> = ReadonlyArray<reado
  */
 export declare function HashMap<Key extends Top, Value extends Top>(key: Key, value: Value): HashMap<Key, Value>;
 /**
- * Type-level representation of a `ReadonlySet` schema whose values are validated
- * by the provided element schema.
- *
- * **When to use**
- *
- * Use to name or constrain the schema type produced by `ReadonlySet` when
- * generic code needs to retain the element schema type.
- *
- * @see {@link ReadonlySet} for constructing this schema type
- * @see {@link ReadonlySetIso} for the array representation used by this schema's ISO
+ * Type-level representation returned by {@link ReadonlySet}.
  *
  * @category ReadonlySet
  * @since 4.0.0
@@ -6499,8 +6343,7 @@ export type ReadonlySetIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
  */
 export declare function ReadonlySet<Value extends Top>(value: Value): $ReadonlySet<Value>;
 /**
- * Schema for an Effect `HashSet` where values must conform to the provided
- * schema.
+ * Type-level representation returned by {@link HashSet}.
  *
  * @category HashSet
  * @since 3.10.0
@@ -6525,8 +6368,7 @@ export type HashSetIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
  */
 export declare function HashSet<Value extends Top>(value: Value): HashSet<Value>;
 /**
- * Schema for an Effect `Chunk` (immutable array-like collection) where values
- * must conform to the provided schema.
+ * Type-level representation returned by {@link Chunk}.
  *
  * @category Chunk
  * @since 3.10.0
@@ -6558,7 +6400,7 @@ export type ChunkIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
  */
 export declare function Chunk<Value extends Top>(value: Value): Chunk<Value>;
 /**
- * Type-level representation of the schema for JavaScript `RegExp` instances.
+ * Type-level representation of {@link RegExp}.
  *
  * @category RegExp
  * @since 4.0.0
@@ -6578,7 +6420,7 @@ export interface RegExp extends instanceOf<globalThis.RegExp> {
  */
 export declare const RegExp: RegExp;
 /**
- * Type-level representation of the schema for JavaScript `URL` instances.
+ * Type-level representation of {@link URL}.
  *
  * @category URL
  * @since 4.0.0
@@ -6600,8 +6442,7 @@ export interface URL extends instanceOf<globalThis.URL> {
  */
 export declare const URL: URL;
 /**
- * Type-level representation of a transformation schema that decodes valid URL
- * strings into JavaScript `URL` instances.
+ * Type-level representation of {@link URLFromString}.
  *
  * @category URL
  * @since 4.0.0
@@ -6625,8 +6466,7 @@ export interface URLFromString extends decodeTo<URL, String> {
  */
 export declare const URLFromString: URLFromString;
 /**
- * Type-level representation of the schema for JavaScript `Date` instances,
- * including invalid dates.
+ * Type-level representation of {@link Date}.
  *
  * @category Date
  * @since 4.0.0
@@ -6639,8 +6479,8 @@ export interface Date extends instanceOf<globalThis.Date> {
  *
  * **When to use**
  *
- * Use to validate in-memory values that must already be JavaScript `Date`
- * instances.
+ * Use to validate in-memory values that must already be JavaScript date
+ * objects.
  *
  * **Details**
  *
@@ -6664,8 +6504,7 @@ export interface Date extends instanceOf<globalThis.Date> {
  */
 export declare const Date: Date;
 /**
- * Type-level representation of a transformation schema that decodes strings into
- * JavaScript `Date` instances.
+ * Type-level representation of {@link DateFromString}.
  *
  * @category Date
  * @since 3.10.0
@@ -6702,8 +6541,7 @@ export interface DateFromString extends decodeTo<Date, String> {
  */
 export declare const DateFromString: DateFromString;
 /**
- * Type-level representation of the `DateValid` schema, which accepts only valid
- * JavaScript `Date` instances.
+ * Type-level representation of {@link DateValid}.
  *
  * @category Date
  * @since 4.0.0
@@ -6724,7 +6562,7 @@ export interface DateValid extends Date {
  */
 export declare const DateValid: DateValid;
 /**
- * Type-level representation of the schema for Effect `Duration` values.
+ * Type-level representation of {@link Duration}.
  *
  * @category Duration
  * @since 3.10.0
@@ -6755,8 +6593,7 @@ export interface Duration extends declare<Duration_.Duration> {
  */
 export declare const Duration: Duration;
 /**
- * Type-level representation of a transformation schema that decodes strings
- * accepted by `Duration.fromInput` into `Duration` values.
+ * Type-level representation of {@link DurationFromString}.
  *
  * @category Duration
  * @since 4.0.0
@@ -6781,8 +6618,7 @@ export interface DurationFromString extends decodeTo<Duration, String> {
  */
 export declare const DurationFromString: DurationFromString;
 /**
- * Type-level representation of a transformation schema that decodes non-negative
- * nanosecond `bigint` values into `Duration` values.
+ * Type-level representation of {@link DurationFromNanos}.
  *
  * @category Duration
  * @since 3.10.0
@@ -6809,8 +6645,7 @@ export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
  */
 export declare const DurationFromNanos: DurationFromNanos;
 /**
- * Type-level representation of a transformation schema that decodes
- * non-negative millisecond numbers into `Duration` values.
+ * Type-level representation of {@link DurationFromMillis}.
  *
  * @category Duration
  * @since 3.10.0
@@ -6838,7 +6673,7 @@ export interface DurationFromMillis extends decodeTo<Duration, Number> {
  */
 export declare const DurationFromMillis: DurationFromMillis;
 /**
- * Type-level representation of the schema for Effect `BigDecimal` values.
+ * Type-level representation of {@link BigDecimal}.
  *
  * @category BigDecimal
  * @since 3.10.0
@@ -6851,7 +6686,7 @@ export interface BigDecimal extends declare<BigDecimal_.BigDecimal> {
  *
  * **When to use**
  *
- * Use when values are already Effect decimal instances and need schema
+ * Use when you already have Effect decimal instances and need schema
  * validation, formatting, equivalence, and JSON string serialization.
  *
  * **Details**
@@ -6867,8 +6702,7 @@ export interface BigDecimal extends declare<BigDecimal_.BigDecimal> {
  */
 export declare const BigDecimal: BigDecimal;
 /**
- * Type-level representation of a transformation schema that decodes strings into
- * `BigDecimal` values.
+ * Type-level representation of {@link BigDecimalFromString}.
  *
  * @category BigDecimal
  * @since 4.0.0
@@ -6905,10 +6739,9 @@ export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
  */
 export declare const BigDecimalFromString: BigDecimalFromString;
 /**
- * Type-level representation of a transformation schema that decodes
- * JSON-encoded strings into `unknown` values.
+ * Type-level representation of {@link UnknownFromJsonString}.
  *
- * @category JSON
+ * @category models
  * @since 4.0.0
  */
 export interface UnknownFromJsonString extends fromJsonString<Unknown> {
@@ -6936,15 +6769,14 @@ export interface UnknownFromJsonString extends fromJsonString<Unknown> {
  * // => { a: 1, b: 2 }
  * ```
  *
- * @category JSON
+ * @category schemas
  * @since 4.0.0
  */
 export declare const UnknownFromJsonString: UnknownFromJsonString;
 /**
- * Type-level representation of a schema that parses a JSON string and then
- * decodes the parsed value with the provided schema.
+ * Type-level representation returned by {@link fromJsonString}.
  *
- * @category JSON
+ * @category models
  * @since 4.0.0
  */
 export interface fromJsonString<S extends Top> extends decodeTo<S, String> {
@@ -7013,14 +6845,14 @@ export interface fromJsonString<S extends Top> extends decodeTo<S, String> {
  * // }
  * ```
  *
- * @category JSON
+ * @category constructors
  * @since 4.0.0
  */
 export declare function fromJsonString<S extends Top>(schema: S): fromJsonString<S>;
 /**
- * Type-level representation of the schema for JavaScript `File` instances.
+ * Type-level representation of {@link File}.
  *
- * @category File
+ * @category file
  * @since 4.0.0
  */
 export interface File extends instanceOf<globalThis.File> {
@@ -7034,12 +6866,12 @@ export interface File extends instanceOf<globalThis.File> {
  * The default JSON serializer encodes a `File` as `{ data, type, name, lastModified }`
  * where `data` is base64-encoded.
  *
- * @category File
+ * @category file
  * @since 4.0.0
  */
 export declare const File: File;
 /**
- * Type-level representation of the schema for JavaScript `FormData` instances.
+ * Type-level representation of {@link FormData}.
  *
  * @category FormData
  * @since 4.0.0
@@ -7060,8 +6892,7 @@ export interface FormData extends instanceOf<globalThis.FormData> {
  */
 export declare const FormData: FormData;
 /**
- * Type-level representation of a schema that parses `FormData` into a tree
- * record and then decodes it with the provided schema.
+ * Type-level representation returned by {@link fromFormData}.
  *
  * @category FormData
  * @since 4.0.0
@@ -7159,10 +6990,9 @@ export interface fromFormData<S extends Top> extends decodeTo<S, FormData> {
  */
 export declare function fromFormData<S extends Top>(schema: S): fromFormData<S>;
 /**
- * Type-level representation of the schema for JavaScript `URLSearchParams`
- * instances.
+ * Type-level representation of {@link URLSearchParams}.
  *
- * @category URLSearchParams
+ * @category search params
  * @since 4.0.0
  */
 export interface URLSearchParams extends instanceOf<globalThis.URLSearchParams> {
@@ -7175,15 +7005,14 @@ export interface URLSearchParams extends instanceOf<globalThis.URLSearchParams>
  *
  * The default JSON serializer encodes a `URLSearchParams` as a query string.
  *
- * @category URLSearchParams
+ * @category search params
  * @since 4.0.0
  */
 export declare const URLSearchParams: URLSearchParams;
 /**
- * Type-level representation of a schema that parses `URLSearchParams` into a
- * tree record and then decodes it with the provided schema.
+ * Type-level representation returned by {@link fromURLSearchParams}.
  *
- * @category URLSearchParams
+ * @category search params
  * @since 4.0.0
  */
 export interface fromURLSearchParams<S extends Top> extends decodeTo<S, URLSearchParams> {
@@ -7271,8 +7100,7 @@ export interface fromURLSearchParams<S extends Top> extends decodeTo<S, URLSearc
  */
 export declare function fromURLSearchParams<S extends Top>(schema: S): fromURLSearchParams<S>;
 /**
- * Type-level representation of the `Finite` number schema, which rejects `NaN`,
- * `Infinity`, and `-Infinity`.
+ * Type-level representation of {@link Finite}.
  *
  * @category Number
  * @since 3.10.0
@@ -7288,8 +7116,7 @@ export interface Finite extends Number {
  */
 export declare const Finite: Finite;
 /**
- * Type-level representation of the `Int` schema, which accepts only finite
- * integer numbers.
+ * Type-level representation of {@link Int}.
  *
  * @category Number
  * @since 3.10.0
@@ -7305,8 +7132,7 @@ export interface Int extends Number {
  */
 export declare const Int: Int;
 /**
- * Type-level representation of a transformation schema that decodes strings into
- * numbers using JavaScript number coercion.
+ * Type-level representation of {@link NumberFromString}.
  *
  * @category Number
  * @since 3.10.0
@@ -7333,8 +7159,7 @@ export interface NumberFromString extends decodeTo<Finite, String> {
  */
 export declare const NumberFromString: NumberFromString;
 /**
- * Type-level representation of a transformation schema that decodes strings into
- * finite numbers.
+ * Type-level representation of {@link FiniteFromString}.
  *
  * @category Number
  * @since 4.0.0
@@ -7359,8 +7184,7 @@ export interface FiniteFromString extends decodeTo<Finite, String> {
  */
 export declare const FiniteFromString: FiniteFromString;
 /**
- * Type-level representation of a transformation schema that decodes strings into
- * `bigint` values.
+ * Type-level representation of {@link BigIntFromString}.
  *
  * @category BigInt
  * @since 4.0.0
@@ -7398,10 +7222,9 @@ export interface BigIntFromString extends decodeTo<BigInt, String> {
  */
 export declare const BigIntFromString: BigIntFromString;
 /**
- * Schema interface for `Trimmed`, representing strings with no leading or
- * trailing whitespace.
+ * Type-level representation of {@link Trimmed}.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export interface Trimmed extends String {
@@ -7410,15 +7233,14 @@ export interface Trimmed extends String {
 /**
  * Schema for strings that contains no leading or trailing whitespaces.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export declare const Trimmed: Trimmed;
 /**
- * Schema interface for `Trim`, a transformation that trims leading and trailing
- * whitespace while decoding and encodes the trimmed string unchanged.
+ * Type-level representation of {@link Trim}.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export interface Trim extends decodeTo<Trimmed, String> {
@@ -7435,15 +7257,14 @@ export interface Trim extends decodeTo<Trimmed, String> {
  * Encoding:
  * - The trimmed string is encoded as is.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export declare const Trim: Trim;
 /**
- * Schema interface for `StringFromBase64`, a transformation between RFC4648
- * base64-encoded strings and UTF-8 strings.
+ * Type-level representation of {@link StringFromBase64}.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export interface StringFromBase64 extends decodeTo<String, String> {
@@ -7460,15 +7281,14 @@ export interface StringFromBase64 extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a base64-encoded string.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export declare const StringFromBase64: StringFromBase64;
 /**
- * Schema interface for `StringFromBase64Url`, a transformation between URL-safe
- * base64-encoded strings and UTF-8 strings.
+ * Type-level representation of {@link StringFromBase64Url}.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export interface StringFromBase64Url extends decodeTo<String, String> {
@@ -7485,15 +7305,14 @@ export interface StringFromBase64Url extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a base64 (URL) encoded string.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export declare const StringFromBase64Url: StringFromBase64Url;
 /**
- * Schema interface for `StringFromHex`, a transformation between hex-encoded
- * strings and UTF-8 strings.
+ * Type-level representation of {@link StringFromHex}.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export interface StringFromHex extends decodeTo<String, String> {
@@ -7510,15 +7329,14 @@ export interface StringFromHex extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a hex string.
  *
- * @category String
+ * @category string
  * @since 3.10.0
  */
 export declare const StringFromHex: StringFromHex;
 /**
- * Schema interface for `StringFromUriComponent`, a transformation between
- * URI-component encoded strings and UTF-8 strings.
+ * Type-level representation of {@link StringFromUriComponent}.
  *
- * @category String
+ * @category string
  * @since 3.12.0
  */
 export interface StringFromUriComponent extends decodeTo<String, String> {
@@ -7554,7 +7372,7 @@ export interface StringFromUriComponent extends decodeTo<String, String> {
  * // %7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D
  * ```
  *
- * @category String
+ * @category string
  * @since 3.12.0
  */
 export declare const StringFromUriComponent: StringFromUriComponent;
@@ -7574,7 +7392,7 @@ export declare const PropertyKey: Union<readonly [Finite, Symbol, String]>;
  * The result contains an `issues` array where each issue has a message and an
  * optional path made of property keys or keyed path segments.
  *
- * @category StandardSchema
+ * @category Standard Schema
  * @since 4.0.0
  */
 export declare const StandardSchemaV1FailureResult: Struct<{
@@ -7586,10 +7404,9 @@ export declare const StandardSchemaV1FailureResult: Struct<{
     }>>;
 }>;
 /**
- * Schema interface for `BooleanFromBit`, a transformation between bit literals
- * `0 | 1` and boolean values.
+ * Type-level representation of {@link BooleanFromBit}.
  *
- * @category Boolean
+ * @category boolean
  * @since 4.0.0
  */
 export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0, 1]>> {
@@ -7611,13 +7428,12 @@ export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0,
  * @see {@link Boolean} for validating values that are already booleans
  * @see {@link Literals} for keeping bit literals instead of decoding them
  *
- * @category Boolean
+ * @category boolean
  * @since 4.0.0
  */
 export declare const BooleanFromBit: BooleanFromBit;
 /**
- * Schema interface for `Uint8Array`, representing JavaScript `Uint8Array`
- * instances with base64 JSON encoding.
+ * Type-level representation of {@link Uint8Array}.
  *
  * @category Uint8Array
  * @since 4.0.0
@@ -7639,8 +7455,7 @@ export interface Uint8Array extends instanceOf<globalThis.Uint8Array<ArrayBuffer
  */
 export declare const Uint8Array: Uint8Array;
 /**
- * Schema interface for `Uint8ArrayFromBase64`, a transformation between
- * base64-encoded strings and `Uint8Array` values.
+ * Type-level representation of {@link Uint8ArrayFromBase64}.
  *
  * @category Uint8Array
  * @since 3.10.0
@@ -7665,8 +7480,7 @@ export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
  */
 export declare const Uint8ArrayFromBase64: Uint8ArrayFromBase64;
 /**
- * Schema interface for `Uint8ArrayFromBase64Url`, a transformation between
- * URL-safe base64-encoded strings and `Uint8Array` values.
+ * Type-level representation of {@link Uint8ArrayFromBase64Url}.
  *
  * @category Uint8Array
  * @since 3.10.0
@@ -7691,8 +7505,7 @@ export interface Uint8ArrayFromBase64Url extends decodeTo<Uint8Array, String> {
  */
 export declare const Uint8ArrayFromBase64Url: Uint8ArrayFromBase64Url;
 /**
- * Schema interface for `Uint8ArrayFromHex`, a transformation between
- * hex-encoded strings and `Uint8Array` values.
+ * Type-level representation of {@link Uint8ArrayFromHex}.
  *
  * @category Uint8Array
  * @since 3.10.0
@@ -7717,8 +7530,7 @@ export interface Uint8ArrayFromHex extends decodeTo<Uint8Array, String> {
  */
 export declare const Uint8ArrayFromHex: Uint8ArrayFromHex;
 /**
- * Schema interface for `DateTimeUtc`, representing `DateTime.Utc` values with
- * UTC ISO string JSON encoding.
+ * Type-level representation of {@link DateTimeUtc}.
  *
  * @category DateTime
  * @since 3.10.0
@@ -7749,8 +7561,7 @@ export interface DateTimeUtc extends declare<DateTime.Utc> {
  */
 export declare const DateTimeUtc: DateTimeUtc;
 /**
- * Schema interface for `DateTimeUtcFromDate`, a transformation from valid
- * JavaScript `Date` values to `DateTime.Utc`.
+ * Type-level representation of {@link DateTimeUtcFromDate}.
  *
  * @category DateTime
  * @since 3.12.0
@@ -7763,8 +7574,8 @@ export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
  *
  * **When to use**
  *
- * Use when a boundary provides valid JavaScript `Date` objects but the decoded
- * model should use `DateTime.Utc`.
+ * Use when you need to decode valid JavaScript `Date` objects into
+ * `DateTime.Utc` values.
  *
  * **Details**
  *
@@ -7784,8 +7595,7 @@ export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
  */
 export declare const DateTimeUtcFromDate: DateTimeUtcFromDate;
 /**
- * Schema interface for `DateTimeUtcFromString`, a transformation from date-time
- * strings to `DateTime.Utc`.
+ * Type-level representation of {@link DateTimeUtcFromString}.
  *
  * @category DateTime
  * @since 4.0.0
@@ -7812,8 +7622,7 @@ export interface DateTimeUtcFromString extends decodeTo<DateTimeUtc, String> {
  */
 export declare const DateTimeUtcFromString: DateTimeUtcFromString;
 /**
- * Schema interface for `DateTimeUtcFromMillis`, a transformation between epoch
- * milliseconds and `DateTime.Utc` values.
+ * Type-level representation of {@link DateTimeUtcFromMillis}.
  *
  * @category DateTime
  * @since 4.0.0
@@ -7837,8 +7646,7 @@ export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>
  */
 export declare const DateTimeUtcFromMillis: DateTimeUtcFromMillis;
 /**
- * Schema interface for `TimeZoneOffset`, representing
- * `DateTime.TimeZone.Offset` values encoded as offset milliseconds.
+ * Type-level representation of {@link TimeZoneOffset}.
  *
  * @category DateTime
  * @since 3.10.0
@@ -7860,8 +7668,7 @@ export interface TimeZoneOffset extends declare<DateTime.TimeZone.Offset> {
  */
 export declare const TimeZoneOffset: TimeZoneOffset;
 /**
- * Schema interface for `TimeZoneNamed`, representing
- * `DateTime.TimeZone.Named` values encoded as IANA time zone identifiers.
+ * Type-level representation of {@link TimeZoneNamed}.
  *
  * @category DateTime
  * @since 3.10.0
@@ -7883,8 +7690,7 @@ export interface TimeZoneNamed extends declare<DateTime.TimeZone.Named> {
  */
 export declare const TimeZoneNamed: TimeZoneNamed;
 /**
- * Schema interface for `TimeZoneNamedFromString`, a transformation between IANA
- * time zone identifier strings and `DateTime.TimeZone.Named` values.
+ * Type-level representation of {@link TimeZoneNamedFromString}.
  *
  * @category DateTime
  * @since 4.0.0
@@ -7908,8 +7714,7 @@ export interface TimeZoneNamedFromString extends decodeTo<TimeZoneNamed, String>
  */
 export declare const TimeZoneNamedFromString: TimeZoneNamedFromString;
 /**
- * Schema interface for `TimeZone`, representing `DateTime.TimeZone` values
- * encoded as either IANA identifiers or numeric offset strings.
+ * Type-level representation of {@link TimeZone}.
  *
  * @category DateTime
  * @since 3.10.0
@@ -7932,8 +7737,7 @@ export interface TimeZone extends declare<DateTime.TimeZone> {
  */
 export declare const TimeZone: TimeZone;
 /**
- * Schema interface for `TimeZoneFromString`, a transformation from IANA
- * identifier or offset strings to `DateTime.TimeZone` values.
+ * Type-level representation of {@link TimeZoneFromString}.
  *
  * @category DateTime
  * @since 4.0.0
@@ -7957,8 +7761,7 @@ export interface TimeZoneFromString extends decodeTo<TimeZone, String> {
  */
 export declare const TimeZoneFromString: TimeZoneFromString;
 /**
- * Schema interface for `DateTimeZoned`, representing `DateTime.Zoned` values
- * with ISO offset or named-zone string JSON encoding.
+ * Type-level representation of {@link DateTimeZoned}.
  *
  * @category DateTime
  * @since 3.10.0
@@ -7983,8 +7786,7 @@ export interface DateTimeZoned extends declare<DateTime.Zoned> {
  */
 export declare const DateTimeZoned: DateTimeZoned;
 /**
- * Schema interface for `DateTimeZonedFromString`, a transformation between
- * zoned date-time strings and `DateTime.Zoned` values.
+ * Type-level representation of {@link DateTimeZonedFromString}.
  *
  * @category DateTime
  * @since 4.0.0
@@ -8008,22 +7810,14 @@ export interface DateTimeZonedFromString extends decodeTo<DateTimeZoned, String>
  */
 export declare const DateTimeZonedFromString: DateTimeZonedFromString;
 /**
- * Interface for schema-backed classes created with {@link Class}.
- *
- * **Details**
- *
- * A `Class` is a TypeScript class whose constructor validates its input
- * against a {@link Struct} schema. Instances are always structurally valid.
- *
- * The interface exposes the schema's `fields`, an `identifier` string, and
- * helpers such as `mapFields`, `annotate`, `check`, and `extend`.
+ * Type-level representation returned by {@link Class}.
  *
  * @category models
  * @since 3.10.0
  */
 export interface Class<Self, S extends Top & {
     readonly fields: Struct.Fields;
-}, Inherited> extends Bottom<Self, S["Encoded"], S["DecodingServices"], S["EncodingServices"], AST.Declaration, decodeTo<declareConstructor<Self, S["Encoded"], readonly [S], S["Iso"]>, S>, RequiredKeys<S["~type.make.in"]> extends never ? void | S["~type.make.in"] : S["~type.make.in"], S["Iso"], readonly [S], Self, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+}, Inherited> extends Bottom<Self, S["Encoded"], S["DecodingServices"], S["EncodingServices"], SchemaAST.Declaration, decodeTo<declareConstructor<Self, S["Encoded"], readonly [S], S["Iso"]>, S>, RequiredKeys<S["~type.make.in"]> extends never ? void | S["~type.make.in"] : S["~type.make.in"], S["Iso"], readonly [S], Self, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
     new (...args: {} extends S["~type.make.in"] ? [props?: S["~type.make.in"], options?: MakeOptions] : [props: S["~type.make.in"], options?: MakeOptions]): S["Type"] & Inherited;
     readonly identifier: string;
     readonly fields: S["fields"];
@@ -8057,9 +7851,8 @@ type MissingSelfGeneric<Usage extends string> = `Missing \`Self\` generic - use
  *
  * **When to use**
  *
- * Use to define a schema-backed data class when you want validated
- * construction, schema-derived decoding/encoding, and class-style methods or
- * inheritance.
+ * Use when you need a schema-backed data class with validated construction,
+ * schema-derived decoding/encoding, and class-style methods or inheritance.
  *
  * **Details**
  *
@@ -8118,9 +7911,8 @@ export declare const Class: {
      *
      * **When to use**
      *
-     * Use to define a schema-backed data class when you want validated
-     * construction, schema-derived decoding/encoding, and class-style methods or
-     * inheritance.
+     * Use when you need a schema-backed data class with validated construction,
+     * schema-derived decoding/encoding, and class-style methods or inheritance.
      *
      * **Details**
      *
@@ -8179,9 +7971,8 @@ export declare const Class: {
          *
          * **When to use**
          *
-         * Use to define a schema-backed data class when you want validated
-         * construction, schema-derived decoding/encoding, and class-style methods or
-         * inheritance.
+         * Use when you need a schema-backed data class with validated construction,
+         * schema-derived decoding/encoding, and class-style methods or inheritance.
          *
          * **Details**
          *
@@ -8240,9 +8031,8 @@ export declare const Class: {
          *
          * **When to use**
          *
-         * Use to define a schema-backed data class when you want validated
-         * construction, schema-derived decoding/encoding, and class-style methods or
-         * inheritance.
+         * Use when you need a schema-backed data class with validated construction,
+         * schema-derived decoding/encoding, and class-style methods or inheritance.
          *
          * **Details**
          *
@@ -8709,7 +8499,7 @@ export declare function overrideToFormatter<S extends Top>(toFormatter: () => Fo
  * @since 4.0.0
  */
 export declare function toFormatter<T>(schema: Schema<T>, options?: {
-    readonly onBefore?: ((ast: AST.AST, recur: (ast: AST.AST) => Formatter<any>) => Formatter<any> | undefined) | undefined;
+    readonly onBefore?: ((ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => Formatter<any>) => Formatter<any> | undefined) | undefined;
 }): Formatter<T>;
 /**
  * Overrides the equivalence derivation for a schema by supplying a custom
@@ -8717,10 +8507,10 @@ export declare function toFormatter<T>(schema: Schema<T>, options?: {
  *
  * **When to use**
  *
- * Use when the default structural equivalence derived by {@link toEquivalence}
- * is not appropriate for a type.
+ * Use when you need a custom equivalence instead of the default structural
+ * equivalence derived by {@link toEquivalence}.
  *
- * @category Equivalence
+ * @category instances
  * @since 4.0.0
  */
 export declare function overrideToEquivalence<S extends Top>(toEquivalence: () => Equivalence.Equivalence<S["Type"]>): (self: S) => S["Rebuild"];
@@ -8740,7 +8530,7 @@ export declare function overrideToEquivalence<S extends Top>(toEquivalence: () =
  * console.log(eq({ id: 1, name: "Alice" }, { id: 2, name: "Alice" })) // false
  * ```
  *
- * @category Equivalence
+ * @category instances
  * @since 4.0.0
  */
 export declare function toEquivalence<T>(schema: Schema<T>): Equivalence.Equivalence<T>;
@@ -8756,7 +8546,7 @@ export declare function toRepresentation(schema: Top): SchemaRepresentation.Docu
 /**
  * Options for {@link toJsonSchemaDocument}.
  *
- * @category JsonSchema
+ * @category options
  * @since 4.0.0
  */
 export interface ToJsonSchemaOptions {
@@ -8835,7 +8625,7 @@ export interface ToJsonSchemaOptions {
  * properties and synthesized check descriptions; it does not change the draft
  * target.
  *
- * @category JsonSchema
+ * @category converting
  * @since 4.0.0
  */
 export declare function toJsonSchemaDocument(schema: Top, options?: ToJsonSchemaOptions): JsonSchema.Document<"draft-2020-12">;
@@ -8935,8 +8725,7 @@ export declare function toIsoSource<S extends Top>(_: S): Optic_.Iso<S["Type"],
  */
 export declare function toIsoFocus<S extends Top>(_: S): Optic_.Iso<S["Iso"], S["Iso"]>;
 /**
- * The schema type returned by {@link overrideToCodecIso}. Carries a custom
- * `Iso` type parameter and exposes the original `schema`.
+ * Type-level representation returned by {@link overrideToCodecIso}.
  *
  * @category Optic
  * @since 4.0.0
@@ -8962,15 +8751,15 @@ export interface overrideToCodecIso<S extends Top, Iso> extends Bottom<S["Type"]
  * @since 4.0.0
  */
 export declare function overrideToCodecIso<S extends Top, Iso>(to: Codec<Iso>, transformation: {
-    readonly decode: Getter.Getter<S["Type"], Iso>;
-    readonly encode: Getter.Getter<Iso, S["Type"]>;
+    readonly decode: SchemaGetter.Getter<S["Type"], Iso>;
+    readonly encode: SchemaGetter.Getter<Iso, S["Type"]>;
 }): (schema: S) => overrideToCodecIso<S, Iso>;
 /**
  * Derives a JSON Patch differ from a codec. Serializes values to JSON (via
  * {@link toCodecJson}), computes RFC 6902 JSON Patch operations between old
  * and new values, and can apply patches back to the typed value.
  *
- * @category JsonPatch
+ * @category converting
  * @since 4.0.0
  */
 export declare function toDifferJsonPatch<T, E>(schema: Codec<T, E>): Differ<T, JsonPatch.JsonPatch>;
@@ -9007,14 +8796,14 @@ export declare function Tree<S extends Top>(node: S): Union<readonly [S, $Array<
  * readonly record of `string → Json`. For the corresponding schema, see the
  * {@link Json} const.
  *
- * @category JSON
+ * @category models
  * @since 4.0.0
  */
 export type Json = null | number | boolean | string | JsonArray | JsonObject;
 /**
  * A readonly array of {@link Json} values.
  *
- * @category JSON
+ * @category models
  * @since 4.0.0
  */
 export interface JsonArray extends ReadonlyArray<Json> {
@@ -9022,7 +8811,7 @@ export interface JsonArray extends ReadonlyArray<Json> {
 /**
  * A readonly record whose values are {@link Json} values.
  *
- * @category JSON
+ * @category models
  * @since 4.0.0
  */
 export interface JsonObject {
@@ -9040,7 +8829,7 @@ export interface JsonObject {
  * console.log(result._tag) // "Some"
  * ```
  *
- * @category JSON
+ * @category schemas
  * @since 4.0.0
  */
 export declare const Json: Codec<Json>;
@@ -9048,14 +8837,14 @@ 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
+ * @category models
  * @since 4.0.0
  */
 export type MutableJson = null | number | boolean | string | MutableJsonArray | MutableJsonObject;
 /**
  * A mutable array of {@link MutableJson} values.
  *
- * @category JSON
+ * @category models
  * @since 4.0.0
  */
 export interface MutableJsonArray extends Array<MutableJson> {
@@ -9063,7 +8852,7 @@ export interface MutableJsonArray extends Array<MutableJson> {
 /**
  * A mutable record whose values are {@link MutableJson} values.
  *
- * @category JSON
+ * @category models
  * @since 4.0.0
  */
 export interface MutableJsonObject {
@@ -9073,7 +8862,7 @@ export interface MutableJsonObject {
  * Schema that accepts any mutable JSON-compatible value. See {@link Json} for
  * the immutable variant.
  *
- * @category JSON
+ * @category schemas
  * @since 4.0.0
  */
 export declare const MutableJson: Codec<MutableJson>;
@@ -9249,7 +9038,7 @@ export declare namespace Annotations {
          * filter/refinement instead.
          */
         readonly identifier?: string | undefined;
-        readonly parseOptions?: AST.ParseOptions | undefined;
+        readonly parseOptions?: SchemaAST.ParseOptions | undefined;
         /**
          * Optional metadata used to identify or extend the filter with custom data.
          */
@@ -9298,14 +9087,15 @@ export declare namespace Annotations {
      * @since 4.0.0
      */
     interface Declaration<T, TypeParameters extends ReadonlyArray<Top> = readonly []> extends Bottom<T, TypeParameters> {
-        readonly toCodec?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => AST.Link) | undefined;
-        readonly toCodecJson?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => AST.Link) | undefined;
-        readonly toCodecIso?: ((typeParameters: TypeParameters.Type<TypeParameters>) => AST.Link) | undefined;
+        readonly toCodec?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link) | undefined;
+        readonly toCodecJson?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link) | undefined;
+        readonly toCodecIso?: ((typeParameters: TypeParameters.Type<TypeParameters>) => SchemaAST.Link) | undefined;
         readonly toArbitrary?: ToArbitrary.Declaration<T, TypeParameters> | undefined;
         readonly toEquivalence?: ToEquivalence.Declaration<T, TypeParameters> | undefined;
         readonly toFormatter?: ToFormatter.Declaration<T, TypeParameters> | undefined;
         readonly typeConstructor?: {
             readonly _tag: string;
+            readonly [key: string]: unknown;
         } | undefined;
         readonly generation?: {
             readonly runtime: string;
@@ -9711,7 +9501,7 @@ export declare namespace Annotations {
         };
         readonly isPropertyNames: {
             readonly _tag: "isPropertyNames";
-            readonly propertyNames: AST.AST;
+            readonly propertyNames: SchemaAST.AST;
         };
         readonly isUnique: {
             readonly _tag: "isUnique";