effect 4.0.0-beta.74 → 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";
@@ -166,7 +166,7 @@ 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.
@@ -272,13 +272,18 @@ export interface Bottom<out T, out E, out RD, out RE, out Ast extends AST.AST, o
  * @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`,
@@ -308,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),
@@ -323,7 +328,7 @@ 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>;
 /**
  * Type-level representation returned by {@link declare}.
  *
@@ -338,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)
  *
@@ -504,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> {
 }
 /**
@@ -771,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.
@@ -882,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.
@@ -928,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.
@@ -936,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**
  *
@@ -973,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**
  *
@@ -982,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
@@ -993,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**
  *
@@ -1001,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
@@ -1012,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**
  *
@@ -1023,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
@@ -1034,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**
  *
@@ -1044,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
@@ -1075,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**
  *
@@ -1086,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**
  *
@@ -1122,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**
  *
@@ -1159,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
@@ -1197,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**
  *
@@ -1218,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.
@@ -1248,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
@@ -1259,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**
  *
@@ -1267,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
@@ -1278,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
@@ -1299,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**
  *
@@ -1309,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
@@ -1340,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**
  *
@@ -1351,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**
  *
@@ -1386,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
@@ -1415,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**
  *
@@ -1423,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**
  *
@@ -1463,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.
  *
@@ -1694,7 +1754,7 @@ export declare const toType: toTypeLambda;
  * @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>;
@@ -1715,7 +1775,7 @@ declare const FlipTypeId = "~effect/Schema/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;
 }
@@ -1750,9 +1810,9 @@ export declare function flip<S extends Top>(schema: S): S extends flip<infer F>
  * @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).
@@ -1772,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.
  *
@@ -1831,13 +1891,18 @@ export declare namespace TemplateLiteral {
  * @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
@@ -1880,7 +1945,7 @@ export declare namespace TemplateLiteralParser {
  * @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;
 }
 /**
@@ -1918,7 +1983,7 @@ export declare function TemplateLiteralParser<const Parts extends TemplateLitera
  */
 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;
 }
 /**
@@ -1950,7 +2015,7 @@ export declare function Enum<A extends {
  * @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.
@@ -1965,7 +2030,7 @@ export declare const Never: Never;
  * @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.
@@ -1981,11 +2046,16 @@ export declare const Any: Any;
  * @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
@@ -1997,7 +2067,7 @@ export declare const Unknown: Unknown;
  * @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`.
@@ -2013,7 +2083,7 @@ export declare const Null: Null;
  * @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`.
@@ -2029,7 +2099,7 @@ export declare const Undefined: Undefined;
  * @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"`.
@@ -2044,7 +2114,7 @@ export declare const String: String;
  * @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`.
@@ -2067,7 +2137,7 @@ export declare const Number: Number;
  * @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"`.
@@ -2088,7 +2158,7 @@ export declare const Boolean: Boolean;
  * @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"`.
@@ -2104,7 +2174,7 @@ export declare const Symbol: Symbol;
  * @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"`.
@@ -2126,7 +2196,7 @@ export declare const BigInt: BigInt;
  * @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.
@@ -2141,7 +2211,7 @@ export declare const Void: Void;
  * @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
@@ -2157,7 +2227,7 @@ export declare const ObjectKeyword: ObjectKeyword;
  * @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.
@@ -2337,7 +2407,7 @@ export declare namespace 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.
@@ -2423,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**
  *
@@ -2683,7 +2753,7 @@ export declare namespace 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;
 }
@@ -2733,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
@@ -2744,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.
@@ -2751,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.
@@ -2761,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.
@@ -2771,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.
@@ -2781,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.
@@ -2791,20 +2868,24 @@ 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">;
+    };
 }
 /**
  * Type-level representation returned by {@link StructWithRest}.
@@ -2812,7 +2893,7 @@ export declare namespace 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;
 }
@@ -2827,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.
  *
@@ -2948,7 +3029,7 @@ export declare namespace 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.
@@ -3012,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>;
     };
@@ -3111,7 +3192,7 @@ export declare namespace 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;
 }
@@ -3152,7 +3233,7 @@ export declare function TupleWithRest<S extends Tuple<Tuple.Elements>, const Res
  * @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 {
@@ -3190,7 +3271,7 @@ ArraySchema as Array };
  * @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 {
@@ -3280,16 +3361,16 @@ export declare function UniqueArray<S extends Top>(item: S): UniqueArray<S>;
  * @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";
 }
 /**
@@ -3324,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"];
@@ -3385,7 +3466,7 @@ export declare function Union<const Members extends ReadonlyArray<Top>>(members:
  * @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]>;
@@ -3396,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]>>;
     }>;
@@ -3417,7 +3498,7 @@ 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>;
 /**
  * Type-level representation returned by {@link NullOr}.
  *
@@ -3484,7 +3565,7 @@ export declare const NullishOr: NullishOrLambda;
  * @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
@@ -3528,7 +3609,7 @@ 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"];
 /**
  * Type-level representation returned by {@link refine}.
  *
@@ -3629,7 +3710,7 @@ 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>;
 /**
  * Type-level representation returned by {@link middlewareEncoding}.
  *
@@ -3664,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.
  *
@@ -3687,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**
  *
@@ -3707,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.
  *
@@ -3720,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**
  *
@@ -3740,7 +3823,7 @@ 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>;
 /**
  * Type-level representation returned by {@link decodeTo}.
  *
@@ -3762,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)
  *
@@ -3806,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)
  *
@@ -3850,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.
@@ -3884,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
@@ -3913,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.
@@ -4071,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
@@ -4115,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
@@ -4139,7 +4238,7 @@ export declare function withDecodingDefaultType<S extends Top, R = never>(defaul
  * @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
@@ -4163,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.
  *
@@ -4196,14 +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>;
 /**
  * Type-level representation returned by {@link TaggedStruct}.
  *
  * @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>>;
 /**
@@ -4252,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.
  */
@@ -4336,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;
@@ -4447,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.
  *
@@ -4515,7 +4614,7 @@ export declare function link<T>(): <To extends Top>(encodeTo: To, transformation
  * @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.
@@ -4523,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 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.
  *
@@ -4588,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.
  *
@@ -4606,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.
  *
@@ -4625,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.
@@ -4643,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.
@@ -4656,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.
@@ -4677,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).
@@ -4697,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.
  *
@@ -4716,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).
@@ -4736,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.
  *
@@ -4750,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.
  *
@@ -4764,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.
  *
@@ -4778,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()`.
  *
@@ -4791,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()`.
  *
@@ -4804,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()`.
@@ -4817,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()`.
@@ -4830,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`).
  *
@@ -4849,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.
@@ -4861,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.
@@ -4873,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.
@@ -4885,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.
@@ -4897,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.
@@ -4919,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.
@@ -4932,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).
  *
@@ -4951,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).
@@ -4970,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).
  *
@@ -4989,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).
@@ -5008,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.
@@ -5034,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.
  *
@@ -5052,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).
@@ -5071,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).
@@ -5091,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).
@@ -5111,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")`).
@@ -5131,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).
  *
@@ -5146,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).
@@ -5167,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).
  *
@@ -5182,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).
@@ -5203,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.
@@ -5229,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).
  *
@@ -5244,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).
@@ -5260,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).
  *
@@ -5275,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).
@@ -5291,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.
@@ -5312,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).
@@ -5327,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).
@@ -5342,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.
  *
@@ -5359,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.
@@ -5389,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;
 }>;
 /**
@@ -5411,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;
 }>;
 /**
@@ -5434,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;
 }>;
 /**
@@ -5457,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;
 }>;
 /**
@@ -5480,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;
 }>;
 /**
@@ -5503,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;
 }>;
 /**
@@ -5526,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;
 }>;
 /**
@@ -5550,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.
@@ -5571,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.
@@ -5592,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.
@@ -5609,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.
  *
@@ -5625,7 +5724,7 @@ 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 {@link NonEmptyString}.
  *
@@ -5720,13 +5819,8 @@ 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
@@ -5742,17 +5836,13 @@ 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
@@ -5772,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
@@ -5800,13 +5887,8 @@ 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
@@ -5822,19 +5904,14 @@ 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
@@ -5855,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
@@ -6013,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**
  *
@@ -6185,6 +6255,11 @@ 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
  */
@@ -6404,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**
  *
@@ -6611,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**
@@ -7499,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**
  *
@@ -7742,7 +7817,7 @@ export declare const DateTimeZonedFromString: DateTimeZonedFromString;
  */
 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"];
@@ -7776,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**
  *
@@ -7837,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**
      *
@@ -7898,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**
          *
@@ -7959,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**
          *
@@ -8428,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
@@ -8436,8 +8507,8 @@ 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 instances
  * @since 4.0.0
@@ -8680,8 +8751,8 @@ 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
@@ -8967,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.
          */
@@ -9016,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;
@@ -9429,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";