effect 4.0.0-beta.101 → 4.0.0-beta.103

package/dist/SchemaRepresentation.d.ts

@@ -2,41 +2,123 @@ import type * as JsonSchema from "./JsonSchema.ts";
 import * as Schema from "./Schema.ts";
 import * as SchemaAST from "./SchemaAST.ts";
 /**
- * A custom type declaration, such as `Date`, `Option`, or `ReadonlySet`.
+ * Open persistence identity carried by declarations and opaque checks.
  *
- * **When to use**
- *
- * Use when inspecting or transforming non-primitive schema types.
+ * @category annotations
+ * @since 4.0.0
+ */
+export interface RepresentationAnnotation {
+    readonly id: string;
+    readonly payload: Schema.Json;
+}
+/**
+ * Open persistence identity and schema dependencies carried by opaque checks.
  *
- * **Details**
+ * @category annotations
+ * @since 4.0.0
+ */
+export interface CheckRepresentationAnnotation<S> extends RepresentationAnnotation {
+    readonly schemas?: ReadonlyArray<S> | undefined;
+}
+/**
+ * Input passed to JSON Schema compiler annotations.
  *
- * `typeParameters` holds the inner type arguments, such as the `A` in
- * `Option<A>`. `encodedSchema` is the fallback representation when no
- * {@link Reviver} recognizes this declaration. `annotations.typeConstructor`
- * identifies the declaration kind, such as `{ _tag: "effect/Option" }`.
+ * @since 4.0.0
+ */
+export declare namespace ToJsonSchema {
+    /**
+     * Input for a check compiler.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface CheckInput {
+        readonly type: JsonSchema.Type | undefined;
+        readonly schemas: ReadonlyArray<JsonSchema.JsonSchema>;
+    }
+    /**
+     * JSON Schema compiler for a check.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    type Check = (input: CheckInput) => JsonSchema.JsonSchema;
+}
+/**
+ * Input and output contracts for code generation annotations.
  *
- * @see {@link Reviver}
- * @see {@link toSchemaDefaultReviver}
+ * @since 4.0.0
+ */
+export declare namespace Generation {
+    /**
+     * Input for declaration code generation.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface DeclarationInput {
+        readonly typeParameters: ReadonlyArray<Code>;
+    }
+    /**
+     * Output of declaration code generation.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface DeclarationOutput {
+        readonly runtime: string;
+        readonly Type: string;
+        readonly importDeclarations?: ReadonlyArray<string> | undefined;
+    }
+    /**
+     * Declaration code generator.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    type Declaration = (input: DeclarationInput) => DeclarationOutput;
+    /**
+     * Input for check code generation.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface CheckInput {
+        readonly schemas: ReadonlyArray<Code>;
+    }
+    /**
+     * Output of check code generation.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    interface CheckOutput {
+        readonly runtime: string;
+        readonly importDeclarations?: ReadonlyArray<string> | undefined;
+    }
+    /**
+     * Check code generator.
+     *
+     * @category models
+     * @since 4.0.0
+     */
+    type Check = (input: CheckInput) => CheckOutput;
+}
+/**
+ * A custom opaque declaration.
  *
  * @category models
  * @since 4.0.0
  */
 export interface Declaration {
     readonly _tag: "Declaration";
+    readonly representation?: RepresentationAnnotation | undefined;
     readonly annotations?: Schema.Annotations.Annotations | undefined;
     readonly typeParameters: ReadonlyArray<Representation>;
-    readonly checks: ReadonlyArray<Check<DeclarationMeta>>;
-    readonly encodedSchema: Representation;
+    readonly checks: ReadonlyArray<Check>;
 }
 /**
- * A lazily resolved representation used for recursive schemas.
- *
- * **Details**
- *
- * `thunk` points to the actual representation, possibly via a
- * {@link Reference}. `checks` is always empty on `Suspend` nodes.
- *
- * @see {@link Reference}
+ * A lazily resolved representation.
  *
  * @category models
  * @since 4.0.0
@@ -48,25 +130,7 @@ export interface Suspend {
     readonly thunk: Representation;
 }
 /**
- * A named reference to a definition in the {@link References} map.
- *
- * **When to use**
- *
- * Use when a representation should point to a named definition instead of
- * embedding the definition inline.
- *
- * **Details**
- *
- * `$ref` is the key into `Document.references` or `MultiDocument.references`.
- * References are resolved lazily by {@link toSchema} and
- * {@link toCodeDocument}.
- *
- * **Gotchas**
- *
- * Resolution throws at runtime if the key is not found in the references map.
- *
- * @see {@link References}
- * @see {@link Document}
+ * A named reference.
  *
  * @category models
  * @since 4.0.0
@@ -75,227 +139,155 @@ export interface Reference {
     readonly _tag: "Reference";
     readonly $ref: string;
 }
+interface Keyword<Tag extends string> {
+    readonly _tag: Tag;
+    readonly annotations?: Schema.Annotations.Annotations | undefined;
+    readonly checks: ReadonlyArray<Check>;
+}
 /**
- * The `null` type.
+ * The null keyword representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Null {
-    readonly _tag: "Null";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Null extends Keyword<"Null"> {
 }
 /**
- * The `undefined` type.
+ * The undefined keyword representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Undefined {
-    readonly _tag: "Undefined";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Undefined extends Keyword<"Undefined"> {
 }
 /**
- * The `void` type.
+ * The void keyword representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Void {
-    readonly _tag: "Void";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Void extends Keyword<"Void"> {
 }
 /**
- * The `never` type (no valid values).
+ * The never keyword representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Never {
-    readonly _tag: "Never";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Never extends Keyword<"Never"> {
 }
 /**
- * The `unknown` type (any value accepted).
+ * The unknown keyword representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Unknown {
-    readonly _tag: "Unknown";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Unknown extends Keyword<"Unknown"> {
 }
 /**
- * The `any` type.
+ * The any keyword representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Any {
-    readonly _tag: "Any";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Any extends Keyword<"Any"> {
 }
 /**
- * The `string` type with optional validation checks.
- *
- * **Details**
- *
- * `checks` holds string-specific constraints, such as min/max length, pattern,
- * and UUID checks. `contentMediaType` and `contentSchema` indicate that the
- * string contains encoded data, such as `"application/json"` with a nested
- * schema.
- *
- * @see {@link StringMeta}
- * @see {@link Check}
+ * A string representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface String {
-    readonly _tag: "String";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
-    readonly checks: ReadonlyArray<Check<StringMeta>>;
-    readonly contentMediaType?: string | undefined;
-    readonly contentSchema?: Representation | undefined;
+export interface String extends Keyword<"String"> {
 }
 /**
- * The `number` type with optional validation checks.
- *
- * **Details**
- *
- * `checks` holds number-specific constraints, such as int, finite, min, max,
- * multipleOf, and between checks.
- *
- * @see {@link NumberMeta}
+ * A number representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Number {
-    readonly _tag: "Number";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
-    readonly checks: ReadonlyArray<Check<NumberMeta>>;
+export interface Number extends Keyword<"Number"> {
 }
 /**
- * The `boolean` type.
+ * A boolean representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Boolean {
-    readonly _tag: "Boolean";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Boolean extends Keyword<"Boolean"> {
 }
 /**
- * The `bigint` type with optional validation checks.
- *
- * @see {@link BigIntMeta}
+ * A bigint representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface BigInt {
-    readonly _tag: "BigInt";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
-    readonly checks: ReadonlyArray<Check<BigIntMeta>>;
+export interface BigInt extends Keyword<"BigInt"> {
 }
 /**
- * The `symbol` type.
+ * A symbol representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Symbol {
-    readonly _tag: "Symbol";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Symbol extends Keyword<"Symbol"> {
 }
 /**
- * A specific literal value (`string`, `number`, `boolean`, or `bigint`).
+ * A literal representation.
+ *
+ * **Details**
+ *
+ * The live representation stores the native literal value. Persistent codecs
+ * add an explicit type discriminator when encoding it.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Literal {
-    readonly _tag: "Literal";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
-    readonly literal: string | number | boolean | bigint;
+export interface Literal extends Keyword<"Literal"> {
+    readonly literal: SchemaAST.LiteralValue;
 }
 /**
- * A specific unique `symbol` value.
+ * A unique global symbol representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface UniqueSymbol {
-    readonly _tag: "UniqueSymbol";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface UniqueSymbol extends Keyword<"UniqueSymbol"> {
     readonly symbol: symbol;
 }
 /**
- * The `object` keyword type (matches any non-primitive).
+ * The object keyword representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface ObjectKeyword {
-    readonly _tag: "ObjectKeyword";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface ObjectKeyword extends Keyword<"ObjectKeyword"> {
 }
 /**
- * A TypeScript-style enum. Each entry is a `[name, value]` pair.
+ * An enum representation.
+ *
+ * **Details**
+ *
+ * Enum members are stored as native string or number values. Persistent
+ * codecs add an explicit type discriminator when encoding them.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Enum {
-    readonly _tag: "Enum";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Enum extends Keyword<"Enum"> {
     readonly enums: ReadonlyArray<readonly [string, string | number]>;
 }
 /**
- * A template literal type composed of a sequence of parts (literals, strings,
- * numbers, etc.).
+ * A template literal representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface TemplateLiteral {
-    readonly _tag: "TemplateLiteral";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface TemplateLiteral extends Keyword<"TemplateLiteral"> {
     readonly parts: ReadonlyArray<Representation>;
 }
 /**
- * An array or tuple type.
- *
- * **Details**
- *
- * `elements` are the fixed positional elements, or tuple prefix, and each may
- * be optional. `rest` contains the variadic tail types; a single-element
- * `rest` with no `elements` produces a plain `Array<T>`. `checks` holds
- * array-specific constraints, such as minLength, maxLength, and unique checks.
- *
- * @see {@link Element}
- * @see {@link ArraysMeta}
- *
- * @category models
- * @since 4.0.0
- */
-export interface Arrays {
-    readonly _tag: "Arrays";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
-    readonly elements: ReadonlyArray<Element>;
-    readonly rest: ReadonlyArray<Representation>;
-    readonly checks: ReadonlyArray<Check<ArraysMeta>>;
-}
-/**
- * A positional element within an {@link Arrays} tuple.
- *
- * **Details**
- *
- * `isOptional` indicates whether this element can be absent. `type` is the
- * schema representation for this element's value.
- *
- * @see {@link Arrays}
+ * A tuple element.
  *
  * @category models
  * @since 4.0.0
@@ -306,38 +298,27 @@ export interface Element {
     readonly annotations?: Schema.Annotations.Annotations | undefined;
 }
 /**
- * An object/struct type with named properties and optional index signatures.
- *
- * **Details**
- *
- * `propertySignatures` are the explicitly named fields. `indexSignatures`
- * define catch-all key/value types, such as `Record<string, T>`. `checks`
- * holds object-specific constraints, such as minProperties and maxProperties.
- *
- * @see {@link PropertySignature}
- * @see {@link IndexSignature}
- * @see {@link ObjectsMeta}
+ * An array or tuple representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Objects {
-    readonly _tag: "Objects";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
-    readonly propertySignatures: ReadonlyArray<PropertySignature>;
-    readonly indexSignatures: ReadonlyArray<IndexSignature>;
-    readonly checks: ReadonlyArray<Check<ObjectsMeta>>;
+export interface Arrays extends Keyword<"Arrays"> {
+    readonly elements: ReadonlyArray<Element>;
+    readonly rest: ReadonlyArray<Representation>;
 }
 /**
- * A named property within an {@link Objects} representation.
+ * A property signature.
  *
  * **Details**
  *
- * `name` is the property key, which can be a string, number, or symbol.
- * `isOptional` indicates whether the key can be absent. `isMutable` indicates
- * whether the property is mutable rather than readonly.
+ * The live representation stores the native property key. Persistent codecs
+ * add an explicit type discriminator when encoding it.
  *
- * @see {@link Objects}
+ * **Gotchas**
+ *
+ * Local symbols can be represented while the schema is live, but persistent
+ * codecs reject them because they cannot be reconstructed by identity.
  *
  * @category models
  * @since 4.0.0
@@ -350,15 +331,7 @@ export interface PropertySignature {
     readonly annotations?: Schema.Annotations.Annotations | undefined;
 }
 /**
- * An index signature, such as `[key: string]: number`, within an
- * {@link Objects}.
- *
- * **Details**
- *
- * `parameter` is the key type representation. `type` is the value type
- * representation.
- *
- * @see {@link Objects}
+ * An index signature.
  *
  * @category models
  * @since 4.0.0
@@ -368,1581 +341,493 @@ export interface IndexSignature {
     readonly type: Representation;
 }
 /**
- * A union of multiple representations.
- *
- * **Details**
+ * An object representation.
  *
- * `types` are the union members. `mode` controls JSON Schema output as either
- * `"anyOf"` (the default) or mutually exclusive `"oneOf"`.
+ * @category models
+ * @since 4.0.0
+ */
+export interface Objects extends Keyword<"Objects"> {
+    readonly propertySignatures: ReadonlyArray<PropertySignature>;
+    readonly indexSignatures: ReadonlyArray<IndexSignature>;
+}
+/**
+ * A union representation.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Union {
-    readonly _tag: "Union";
-    readonly annotations?: Schema.Annotations.Annotations | undefined;
+export interface Union extends Keyword<"Union"> {
     readonly types: ReadonlyArray<Representation>;
     readonly mode: "anyOf" | "oneOf";
 }
 /**
- * The core tagged union of all supported schema shapes.
- *
- * **Details**
- *
- * Each variant has a `_tag` discriminator. Switch on `_tag` to handle each
- * shape. Most variants carry optional `annotations` and some carry `checks`
- * for validation constraints.
- *
- * @see {@link Document}
- * @see {@link fromAST}
+ * The structural schema representation.
  *
  * @category models
  * @since 4.0.0
  */
 export type Representation = Declaration | Reference | Suspend | Null | Undefined | Void | Never | Unknown | Any | String | Number | Boolean | BigInt | Symbol | Literal | UniqueSymbol | ObjectKeyword | Enum | TemplateLiteral | Arrays | Objects | Union;
 /**
- * A validation constraint attached to a type. Either a single {@link Filter}
- * or a {@link FilterGroup} combining multiple checks.
- *
- * @see {@link Filter}
- * @see {@link FilterGroup}
+ * A structural check.
  *
  * @category models
  * @since 4.0.0
  */
-export type Check<M> = Filter<M> | FilterGroup<M>;
+export type Check = Filter | FilterGroup;
 /**
- * A single validation constraint with typed metadata describing the check
- * (e.g. `{ _tag: "isMinLength", minLength: 3 }`).
- *
- * @see {@link Check}
+ * An opaque leaf check.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Filter<M> {
+export interface Filter {
     readonly _tag: "Filter";
-    readonly annotations?: Schema.Annotations.Filter | undefined;
-    readonly meta: M;
+    readonly representation?: CheckRepresentationAnnotation<Representation> | undefined;
+    readonly annotations?: Schema.Annotations.Annotations | undefined;
+    readonly aborted: boolean;
 }
 /**
- * A group of validation constraints that are logically combined. Contains
- * at least one {@link Check}.
- *
- * @see {@link Check}
+ * A non-empty group of checks.
  *
  * @category models
  * @since 4.0.0
  */
-export interface FilterGroup<M> {
+export interface FilterGroup {
     readonly _tag: "FilterGroup";
-    readonly annotations?: Schema.Annotations.Filter | undefined;
-    readonly checks: readonly [Check<M>, ...Array<Check<M>>];
+    readonly representation?: CheckRepresentationAnnotation<Representation> | undefined;
+    readonly annotations?: Schema.Annotations.Annotations | undefined;
+    readonly checks: readonly [Check, ...Array<Check>];
 }
 /**
- * Metadata union for string-specific validation checks (minLength, maxLength,
- * pattern, UUID, trimmed, etc.).
- *
- * @see {@link String}
- * @see {@link Check}
+ * Named representation definitions.
  *
  * @category models
  * @since 4.0.0
  */
-export type StringMeta = Schema.Annotations.BuiltInMetaDefinitions["isStringFinite" | "isStringBigInt" | "isStringSymbol" | "isMinLength" | "isMaxLength" | "isPattern" | "isLengthBetween" | "isTrimmed" | "isUUID" | "isGUID" | "isULID" | "isBase64" | "isBase64Url" | "isStartsWith" | "isEndsWith" | "isIncludes" | "isUppercased" | "isLowercased" | "isCapitalized" | "isUncapitalized"];
+export interface References {
+    readonly [$ref: string]: Representation;
+}
 /**
- * Metadata union for number-specific validation checks (int, finite,
- * min, max, multipleOf, between).
- *
- * @see {@link Number}
- * @see {@link Check}
+ * A single representation and its definitions.
  *
  * @category models
  * @since 4.0.0
  */
-export type NumberMeta = Schema.Annotations.BuiltInMetaDefinitions["isInt" | "isFinite" | "isMultipleOf" | "isGreaterThanOrEqualTo" | "isLessThanOrEqualTo" | "isGreaterThan" | "isLessThan" | "isBetween"];
+export interface Document {
+    readonly representation: Representation;
+    readonly references: References;
+}
 /**
- * Metadata union for bigint-specific validation checks (min, max, between).
- *
- * @see {@link BigInt}
- * @see {@link Check}
+ * Multiple representations sharing definitions.
  *
  * @category models
  * @since 4.0.0
  */
-export type BigIntMeta = Schema.Annotations.BuiltInMetaDefinitions["isGreaterThanOrEqualToBigInt" | "isLessThanOrEqualToBigInt" | "isGreaterThanBigInt" | "isLessThanBigInt" | "isBetweenBigInt"];
+export interface MultiDocument {
+    readonly representations: readonly [Representation, ...Array<Representation>];
+    readonly references: References;
+}
 /**
- * Metadata union for array-specific validation checks (minLength, maxLength,
- * length, unique).
- *
- * @see {@link Arrays}
- * @see {@link Check}
+ * Reviver for a declaration.
  *
  * @category models
  * @since 4.0.0
  */
-export type ArraysMeta = Schema.Annotations.BuiltInMetaDefinitions["isMinLength" | "isMaxLength" | "isLengthBetween" | "isUnique"];
+export interface DeclarationReviver<P> {
+    readonly id: string;
+    readonly payloadSchema: Schema.Decoder<P>;
+    readonly revive: (input: {
+        readonly payload: P;
+        readonly typeParameters: ReadonlyArray<Schema.Top>;
+        readonly annotations: Schema.Annotations.Annotations | undefined;
+    }) => Schema.Top;
+}
 /**
- * Metadata union for object-specific validation checks (minProperties,
- * maxProperties, propertiesLength, propertyNames).
- *
- * @see {@link Objects}
- * @see {@link Check}
+ * Reviver for a leaf check.
  *
  * @category models
  * @since 4.0.0
  */
-export type ObjectsMeta = Schema.Annotations.BuiltInMetaDefinitions["isMinProperties" | "isMaxProperties" | "isPropertiesLengthBetween"] | {
-    readonly _tag: "isPropertyNames";
-    readonly propertyNames: Representation;
-};
+export interface FilterReviver<P> {
+    readonly id: string;
+    readonly payloadSchema: Schema.Decoder<P>;
+    readonly revive: (input: {
+        readonly payload: P;
+        readonly schemas: ReadonlyArray<Schema.Top>;
+        readonly annotations: Schema.Annotations.Filter | undefined;
+    }) => SchemaAST.Filter<any>;
+}
 /**
- * Metadata union for Date-specific validation checks (valid, min, max, between).
- *
- * @see {@link Declaration}
- * @see {@link DeclarationMeta}
+ * Reviver for a check group.
  *
  * @category models
  * @since 4.0.0
  */
-export type DateMeta = Schema.Annotations.BuiltInMetaDefinitions["isDateValid" | "isGreaterThanDate" | "isGreaterThanOrEqualToDate" | "isLessThanDate" | "isLessThanOrEqualToDate" | "isBetweenDate"];
+export interface FilterGroupReviver<P> {
+    readonly id: string;
+    readonly payloadSchema: Schema.Decoder<P>;
+    readonly revive: (input: {
+        readonly payload: P;
+        readonly schemas: ReadonlyArray<Schema.Top>;
+        readonly annotations: Schema.Annotations.Filter | undefined;
+    }) => SchemaAST.FilterGroup<any>;
+}
 /**
- * Metadata union for size-based validation checks (minSize, maxSize, size).
- * Used for collection types like `Set`, `Map`.
- *
- * @see {@link Declaration}
- * @see {@link DeclarationMeta}
+ * A check reviver.
  *
  * @category models
  * @since 4.0.0
  */
-export type SizeMeta = Schema.Annotations.BuiltInMetaDefinitions["isMinSize" | "isMaxSize" | "isSizeBetween"];
+export type CheckReviver<P> = FilterReviver<P> | FilterGroupReviver<P>;
 /**
- * Metadata union for {@link Declaration} checks — either {@link DateMeta}
- * or {@link SizeMeta}.
+ * A typed reviver.
  *
  * @category models
  * @since 4.0.0
  */
-export type DeclarationMeta = DateMeta | SizeMeta;
+export type Reviver<P> = DeclarationReviver<P> | CheckReviver<P>;
 /**
- * A string-keyed map of named {@link Representation} definitions. Used by
- * {@link Document} and {@link MultiDocument} for `$ref` resolution (analogous
- * to JSON Schema `$defs`).
- *
- * @see {@link Reference}
- * @see {@link Document}
+ * A reviver erased only at collection boundaries.
  *
  * @category models
  * @since 4.0.0
  */
-export interface References {
-    readonly [$ref: string]: Representation;
-}
+export type AnyReviver = Reviver<any>;
 /**
- * A single {@link Representation} together with its named {@link References}.
- *
- * **When to use**
+ * Creates a declaration reviver while inferring its payload type from `payloadSchema`.
  *
- * Use when representing a single Schema AST together with its named references
- * before reconstructing a runtime Schema, converting to JSON Schema, or
- * wrapping it as a {@link MultiDocument}.
- *
- * @see {@link MultiDocument}
- * @see {@link fromAST}
- *
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export type Document = {
-    readonly representation: Representation;
-    readonly references: References;
-};
+export declare const makeDeclarationReviver: <P>(id: string, payloadSchema: Schema.Decoder<P>, revive: DeclarationReviver<P>["revive"]) => DeclarationReviver<P>;
 /**
- * One or more {@link Representation}s sharing a common {@link References} map.
- *
- * **When to use**
+ * Creates a filter reviver while inferring its payload type from `payloadSchema`.
  *
- * Use when you use {@link fromASTs} to create this from multiple Schema ASTs,
- * {@link toCodeDocument} to generate TypeScript code, and
- * {@link toJsonSchemaMultiDocument} to convert to JSON Schema.
- *
- * @see {@link Document}
- * @see {@link fromASTs}
- *
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export type MultiDocument = {
-    readonly representations: readonly [Representation, ...Array<Representation>];
-    readonly references: References;
-};
+export declare const makeFilterReviver: <P>(id: string, payloadSchema: Schema.Decoder<P>, revive: FilterReviver<P>["revive"]) => FilterReviver<P>;
 /**
- * A tree of primitive values used to serialize annotations to JSON.
+ * Creates a filter group reviver while inferring its payload type from `payloadSchema`.
  *
- * @category Tree
+ * @category constructors
  * @since 4.0.0
  */
-export type PrimitiveTree = Schema.Tree<null | number | boolean | bigint | symbol | string>;
+export declare const makeFilterGroupReviver: <P>(id: string, payloadSchema: Schema.Decoder<P>, revive: FilterGroupReviver<P>["revive"]) => FilterGroupReviver<P>;
 /**
- * Schema for {@link PrimitiveTree}.
+ * Options for importing JSON Schema Draft 2020-12 documents.
  *
  * **When to use**
  *
- * Use to validate recursive annotation metadata trees whose leaves are `null`,
- * `number`, `boolean`, `bigint`, `symbol`, or `string`.
+ * Use when each JSON Schema node must be transformed before it is translated.
  *
- * @see {@link PrimitiveTree} for the recursive tree type accepted by this codec
- * @see {@link $Annotations} for the annotation codec that filters values through this codec
+ * **Gotchas**
  *
- * @category schemas
+ * `onEnter` must return a JSON Schema object. Its result is used directly, and exceptions raised by the callback pass through unchanged.
+ *
+ * @category models
  * @since 4.0.0
  */
-export declare const $PrimitiveTree: Schema.Codec<PrimitiveTree>;
+export interface FromJsonSchemaOptions {
+    readonly onEnter?: ((schema: JsonSchema.JsonSchema) => JsonSchema.JsonSchema) | undefined;
+}
 /**
- * Schema for serializing public `Schema.Annotations.Annotations` values. It
- * filters out internal annotation keys and non-primitive values during
- * encoding.
- *
- * **When to use**
+ * Runtime and TypeScript source generated for one schema.
  *
- * Use to serialize schema annotations in representation schemas while retaining
- * only primitive-tree metadata.
- *
- * **Details**
- *
- * Decoding is passthrough. Encoding removes internal annotation keys and values
- * that are not accepted by `$PrimitiveTree`.
- *
- * @see {@link $PrimitiveTree} for the codec used to filter annotation values
- *
- * @category schemas
+ * @category models
  * @since 4.0.0
  */
-export declare const $Annotations: Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>;
+export interface Code {
+    readonly runtime: string;
+    readonly Type: string;
+}
 /**
- * Schema for the {@link Null} representation node.
+ * Creates generated runtime and TypeScript source strings for a schema.
  *
- * @category schemas
+ * @category constructors
  * @since 4.0.0
  */
-export declare const $Null: Schema.Struct<{
-    readonly _tag: Schema.tag<"Null">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
+export declare const makeCode: (runtime: string, Type: string) => Code;
 /**
- * Schema for the {@link Undefined} representation node.
+ * Auxiliary source artifact emitted while generating schema code.
  *
- * @category schemas
+ * @category models
  * @since 4.0.0
  */
-export declare const $Undefined: Schema.Struct<{
-    readonly _tag: Schema.tag<"Undefined">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
+export type Artifact = {
+    readonly _tag: "Symbol";
+    readonly identifier: string;
+    readonly code: Code;
+} | {
+    readonly _tag: "Enum";
+    readonly identifier: string;
+    readonly code: Code;
+} | {
+    readonly _tag: "Import";
+    readonly importDeclaration: string;
+};
 /**
- * Schema for the {@link Void} representation node.
+ * Generated schema code together with named references and auxiliary artifacts.
  *
- * @category schemas
+ * @category models
  * @since 4.0.0
- */
-export declare const $Void: Schema.Struct<{
-    readonly _tag: Schema.tag<"Void">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
-/**
- * Schema for the {@link Never} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Never: Schema.Struct<{
-    readonly _tag: Schema.tag<"Never">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
+ */
+export interface CodeDocument {
+    readonly codes: ReadonlyArray<Code>;
+    readonly references: {
+        readonly nonRecursives: ReadonlyArray<{
+            readonly $ref: string;
+            readonly code: Code;
+        }>;
+        readonly recursives: Readonly<Record<string, Code>>;
+    };
+    readonly artifacts: ReadonlyArray<Artifact>;
+}
 /**
- * Schema for the {@link Unknown} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Unknown: Schema.Struct<{
-    readonly _tag: Schema.tag<"Unknown">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
-/**
- * Schema for the {@link Any} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Any: Schema.Struct<{
-    readonly _tag: Schema.tag<"Any">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
-/**
- * Schema for {@link StringMeta}.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $StringMeta: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.tag<"isStringFinite">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isStringBigInt">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isStringSymbol">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isTrimmed">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isUUID">;
-    readonly regExp: Schema.RegExp;
-    readonly version: Schema.UndefinedOr<Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>>;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isGUID">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isULID">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isBase64">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isBase64Url">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isStartsWith">;
-    readonly startsWith: Schema.String;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isEndsWith">;
-    readonly endsWith: Schema.String;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isIncludes">;
-    readonly includes: Schema.String;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isUppercased">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isLowercased">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isCapitalized">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isUncapitalized">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isMinLength">;
-    readonly minLength: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isMaxLength">;
-    readonly maxLength: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isPattern">;
-    readonly regExp: Schema.RegExp;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isLengthBetween">;
-    readonly minimum: Schema.Int;
-    readonly maximum: Schema.Int;
-}>]>;
-/**
- * Schema for the {@link String} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $String: Schema.Struct<{
-    readonly _tag: Schema.tag<"String">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly checks: Schema.$Array<Schema.Codec<Check<{
-        readonly _tag: "isStringFinite";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isStringBigInt";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isStringSymbol";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isTrimmed";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isUUID";
-        readonly regExp: RegExp;
-        readonly version: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | undefined;
-    } | {
-        readonly _tag: "isGUID";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isULID";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isBase64";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isBase64Url";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isStartsWith";
-        readonly startsWith: string;
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isEndsWith";
-        readonly endsWith: string;
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isIncludes";
-        readonly includes: string;
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isUppercased";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isLowercased";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isCapitalized";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isUncapitalized";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isMinLength";
-        readonly minLength: number;
-    } | {
-        readonly _tag: "isMaxLength";
-        readonly maxLength: number;
-    } | {
-        readonly _tag: "isPattern";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isLengthBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-    }>, Check<{
-        readonly _tag: "isStringFinite";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isStringBigInt";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isStringSymbol";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isTrimmed";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isUUID";
-        readonly regExp: RegExp;
-        readonly version: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | undefined;
-    } | {
-        readonly _tag: "isGUID";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isULID";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isBase64";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isBase64Url";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isStartsWith";
-        readonly startsWith: string;
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isEndsWith";
-        readonly endsWith: string;
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isIncludes";
-        readonly includes: string;
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isUppercased";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isLowercased";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isCapitalized";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isUncapitalized";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isMinLength";
-        readonly minLength: number;
-    } | {
-        readonly _tag: "isMaxLength";
-        readonly maxLength: number;
-    } | {
-        readonly _tag: "isPattern";
-        readonly regExp: RegExp;
-    } | {
-        readonly _tag: "isLengthBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-    }>, never, never>>;
-    readonly contentMediaType: Schema.optional<Schema.String>;
-    readonly contentSchema: Schema.optional<Schema.suspend<$Representation>>;
-}>;
-/**
- * Schema for {@link NumberMeta}.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $NumberMeta: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.tag<"isInt">;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isMultipleOf">;
-    readonly divisor: Schema.Finite;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isFinite">;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isGreaterThan">;
-    readonly exclusiveMinimum: Schema.Finite;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isGreaterThanOrEqualTo">;
-    readonly minimum: Schema.Finite;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isLessThan">;
-    readonly exclusiveMaximum: Schema.Finite;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isLessThanOrEqualTo">;
-    readonly maximum: Schema.Finite;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isBetween">;
-    readonly minimum: Schema.Finite;
-    readonly maximum: Schema.Finite;
-    readonly exclusiveMinimum: Schema.optional<Schema.Boolean>;
-    readonly exclusiveMaximum: Schema.optional<Schema.Boolean>;
-}>]>;
-/**
- * Schema for the {@link Number} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Number: Schema.Struct<{
-    readonly _tag: Schema.tag<"Number">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly checks: Schema.$Array<Schema.Codec<Check<{
-        readonly _tag: "isInt";
-    } | {
-        readonly _tag: "isMultipleOf";
-        readonly divisor: number;
-    } | {
-        readonly _tag: "isFinite";
-    } | {
-        readonly _tag: "isGreaterThan";
-        readonly exclusiveMinimum: number;
-    } | {
-        readonly _tag: "isGreaterThanOrEqualTo";
-        readonly minimum: number;
-    } | {
-        readonly _tag: "isLessThan";
-        readonly exclusiveMaximum: number;
-    } | {
-        readonly _tag: "isLessThanOrEqualTo";
-        readonly maximum: number;
-    } | {
-        readonly _tag: "isBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-        readonly exclusiveMinimum?: boolean | undefined;
-        readonly exclusiveMaximum?: boolean | undefined;
-    }>, Check<{
-        readonly _tag: "isInt";
-    } | {
-        readonly _tag: "isMultipleOf";
-        readonly divisor: number;
-    } | {
-        readonly _tag: "isFinite";
-    } | {
-        readonly _tag: "isGreaterThan";
-        readonly exclusiveMinimum: number;
-    } | {
-        readonly _tag: "isGreaterThanOrEqualTo";
-        readonly minimum: number;
-    } | {
-        readonly _tag: "isLessThan";
-        readonly exclusiveMaximum: number;
-    } | {
-        readonly _tag: "isLessThanOrEqualTo";
-        readonly maximum: number;
-    } | {
-        readonly _tag: "isBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-        readonly exclusiveMinimum?: boolean | undefined;
-        readonly exclusiveMaximum?: boolean | undefined;
-    }>, never, never>>;
-}>;
-/**
- * Schema for the {@link Boolean} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Boolean: Schema.Struct<{
-    readonly _tag: Schema.tag<"Boolean">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
-/**
- * Schema for the {@link BigInt} representation node.
- *
- * **When to use**
- *
- * Use to encode, decode, or validate serialized `BigInt` representation nodes,
- * not application `bigint` values.
+ * Lowers the encoded side of an AST to a live representation document.
  *
  * **Details**
  *
- * Accepts representation nodes with `_tag: "BigInt"`, optional annotations,
- * and bigint-specific validation metadata in `checks`.
+ * Apply `SchemaAST.toType` to the AST first to lower its type side instead.
  *
- * @see {@link BigIntMeta} for the metadata accepted by the `checks` array
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $BigInt: Schema.Struct<{
-    readonly _tag: Schema.tag<"BigInt">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly checks: Schema.$Array<Schema.Codec<Check<{
-        readonly _tag: "isGreaterThanBigInt";
-        readonly exclusiveMinimum: bigint;
-    } | {
-        readonly _tag: "isGreaterThanOrEqualToBigInt";
-        readonly minimum: bigint;
-    } | {
-        readonly _tag: "isLessThanBigInt";
-        readonly exclusiveMaximum: bigint;
-    } | {
-        readonly _tag: "isLessThanOrEqualToBigInt";
-        readonly maximum: bigint;
-    } | {
-        readonly _tag: "isBetweenBigInt";
-        readonly minimum: bigint;
-        readonly maximum: bigint;
-        readonly exclusiveMinimum?: boolean | undefined;
-        readonly exclusiveMaximum?: boolean | undefined;
-    }>, Check<{
-        readonly _tag: "isGreaterThanBigInt";
-        readonly exclusiveMinimum: bigint;
-    } | {
-        readonly _tag: "isGreaterThanOrEqualToBigInt";
-        readonly minimum: bigint;
-    } | {
-        readonly _tag: "isLessThanBigInt";
-        readonly exclusiveMaximum: bigint;
-    } | {
-        readonly _tag: "isLessThanOrEqualToBigInt";
-        readonly maximum: bigint;
-    } | {
-        readonly _tag: "isBetweenBigInt";
-        readonly minimum: bigint;
-        readonly maximum: bigint;
-        readonly exclusiveMinimum?: boolean | undefined;
-        readonly exclusiveMaximum?: boolean | undefined;
-    }>, never, never>>;
-}>;
-/**
- * Schema for the {@link Symbol} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Symbol: Schema.Struct<{
-    readonly _tag: Schema.tag<"Symbol">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
-/**
- * Schema for the literal value types allowed in a {@link Literal} node
- * (string, finite number, boolean, or bigint).
- *
- * @category schemas
+ * @category constructors
  * @since 4.0.0
  */
-export declare const $LiteralValue: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.BigInt]>;
-/**
- * Schema for the {@link Literal} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Literal: Schema.Struct<{
-    readonly _tag: Schema.tag<"Literal">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly literal: Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.BigInt]>;
-}>;
+export declare function toRepresentation(ast: SchemaAST.AST): Document;
 /**
- * Schema for the {@link UniqueSymbol} representation node.
+ * Lowers one or more AST encoded sides in a shared reference environment.
  *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $UniqueSymbol: Schema.Struct<{
-    readonly _tag: Schema.tag<"UniqueSymbol">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly symbol: Schema.Symbol;
-}>;
-/**
- * Schema for the {@link ObjectKeyword} representation node.
+ * **Details**
  *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $ObjectKeyword: Schema.Struct<{
-    readonly _tag: Schema.tag<"ObjectKeyword">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
-/**
- * Schema for the {@link Enum} representation node.
+ * Apply `SchemaAST.toType` to an AST first to lower its type side instead.
  *
- * @category schemas
+ * @category constructors
  * @since 4.0.0
  */
-export declare const $Enum: Schema.Struct<{
-    readonly _tag: Schema.tag<"Enum">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly enums: Schema.$Array<Schema.Tuple<readonly [Schema.String, Schema.Union<readonly [Schema.String, Schema.Number]>]>>;
-}>;
-/**
- * Schema for the {@link TemplateLiteral} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $TemplateLiteral: Schema.Struct<{
-    readonly _tag: Schema.tag<"TemplateLiteral">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly parts: Schema.$Array<Schema.suspend<$Representation>>;
-}>;
+export declare function toRepresentations(asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]): MultiDocument;
 /**
- * Schema for the {@link Element} type (positional tuple element).
+ * Wraps a single representation document as a multi-document with one root.
  *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Element: Schema.Struct<{
-    readonly isOptional: Schema.Boolean;
-    readonly type: Schema.suspend<$Representation>;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-}>;
-/**
- * Schema for the {@link Arrays} representation node.
+ * **When to use**
  *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Arrays: Schema.Struct<{
-    readonly _tag: Schema.tag<"Arrays">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly elements: Schema.$Array<Schema.Struct<{
-        readonly isOptional: Schema.Boolean;
-        readonly type: Schema.suspend<$Representation>;
-        readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    }>>;
-    readonly rest: Schema.$Array<Schema.suspend<$Representation>>;
-    readonly checks: Schema.$Array<Schema.Codec<Check<{
-        readonly _tag: "isMinLength";
-        readonly minLength: number;
-    } | {
-        readonly _tag: "isMaxLength";
-        readonly maxLength: number;
-    } | {
-        readonly _tag: "isLengthBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-    } | {
-        readonly _tag: "isUnique";
-    }>, Check<{
-        readonly _tag: "isMinLength";
-        readonly minLength: number;
-    } | {
-        readonly _tag: "isMaxLength";
-        readonly maxLength: number;
-    } | {
-        readonly _tag: "isLengthBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-    } | {
-        readonly _tag: "isUnique";
-    }>, never, never>>;
-}>;
-/**
- * Schema for the {@link PropertySignature} type.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $PropertySignature: Schema.Struct<{
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly name: Schema.Union<readonly [Schema.Finite, Schema.Symbol, Schema.String]>;
-    readonly type: Schema.suspend<$Representation>;
-    readonly isOptional: Schema.Boolean;
-    readonly isMutable: Schema.Boolean;
-}>;
-/**
- * Schema for the {@link IndexSignature} type.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $IndexSignature: Schema.Struct<{
-    readonly parameter: Schema.suspend<$Representation>;
-    readonly type: Schema.suspend<$Representation>;
-}>;
-/**
- * Schema for {@link ObjectsMeta}.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $ObjectsMeta: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.tag<"isMinProperties">;
-    readonly minProperties: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isMaxProperties">;
-    readonly maxProperties: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isPropertiesLengthBetween">;
-    readonly minimum: Schema.Int;
-    readonly maximum: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isPropertyNames">;
-    readonly propertyNames: Schema.suspend<$Representation>;
-}>]>;
-/**
- * Schema for the {@link Objects} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Objects: Schema.Struct<{
-    readonly _tag: Schema.tag<"Objects">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly propertySignatures: Schema.$Array<Schema.Struct<{
-        readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-        readonly name: Schema.Union<readonly [Schema.Finite, Schema.Symbol, Schema.String]>;
-        readonly type: Schema.suspend<$Representation>;
-        readonly isOptional: Schema.Boolean;
-        readonly isMutable: Schema.Boolean;
-    }>>;
-    readonly indexSignatures: Schema.$Array<Schema.Struct<{
-        readonly parameter: Schema.suspend<$Representation>;
-        readonly type: Schema.suspend<$Representation>;
-    }>>;
-    readonly checks: Schema.$Array<Schema.Codec<Check<{
-        readonly _tag: "isMinProperties";
-        readonly minProperties: number;
-    } | {
-        readonly _tag: "isMaxProperties";
-        readonly maxProperties: number;
-    } | {
-        readonly _tag: "isPropertiesLengthBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-    } | {
-        readonly _tag: "isPropertyNames";
-        readonly propertyNames: Representation;
-    }>, Check<{
-        readonly _tag: "isMinProperties";
-        readonly minProperties: number;
-    } | {
-        readonly _tag: "isMaxProperties";
-        readonly maxProperties: number;
-    } | {
-        readonly _tag: "isPropertiesLengthBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-    } | {
-        readonly _tag: "isPropertyNames";
-        readonly propertyNames: Representation;
-    }>, never, never>>;
-}>;
-/**
- * Schema for the {@link Union} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Union: Schema.Struct<{
-    readonly _tag: Schema.tag<"Union">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly types: Schema.$Array<Schema.suspend<$Representation>>;
-    readonly mode: Schema.Literals<readonly ["anyOf", "oneOf"]>;
-}>;
-/**
- * Schema for the {@link Reference} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Reference: Schema.Struct<{
-    readonly _tag: Schema.tag<"Reference">;
-    readonly $ref: Schema.String;
-}>;
-/**
- * Schema for {@link DateMeta}.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $DateMeta: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.tag<"isDateValid">;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isGreaterThanDate">;
-    readonly exclusiveMinimum: Schema.Date;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isGreaterThanOrEqualToDate">;
-    readonly minimum: Schema.Date;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isLessThanDate">;
-    readonly exclusiveMaximum: Schema.Date;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isLessThanOrEqualToDate">;
-    readonly maximum: Schema.Date;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isBetweenDate">;
-    readonly minimum: Schema.Date;
-    readonly maximum: Schema.Date;
-    readonly exclusiveMinimum: Schema.optional<Schema.Boolean>;
-    readonly exclusiveMaximum: Schema.optional<Schema.Boolean>;
-}>]>;
-/**
- * Schema for {@link SizeMeta}.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $SizeMeta: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.tag<"isMinSize">;
-    readonly minSize: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isMaxSize">;
-    readonly maxSize: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isSizeBetween">;
-    readonly minimum: Schema.Int;
-    readonly maximum: Schema.Int;
-}>]>;
-/**
- * Schema for {@link DeclarationMeta}.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $DeclarationMeta: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.tag<"isDateValid">;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isGreaterThanDate">;
-    readonly exclusiveMinimum: Schema.Date;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isGreaterThanOrEqualToDate">;
-    readonly minimum: Schema.Date;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isLessThanDate">;
-    readonly exclusiveMaximum: Schema.Date;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isLessThanOrEqualToDate">;
-    readonly maximum: Schema.Date;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isBetweenDate">;
-    readonly minimum: Schema.Date;
-    readonly maximum: Schema.Date;
-    readonly exclusiveMinimum: Schema.optional<Schema.Boolean>;
-    readonly exclusiveMaximum: Schema.optional<Schema.Boolean>;
-}>]>, Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.tag<"isMinSize">;
-    readonly minSize: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isMaxSize">;
-    readonly maxSize: Schema.Int;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"isSizeBetween">;
-    readonly minimum: Schema.Int;
-    readonly maximum: Schema.Int;
-}>]>]>;
-/**
- * Schema for the {@link Declaration} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Declaration: Schema.Struct<{
-    readonly _tag: Schema.tag<"Declaration">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly typeParameters: Schema.$Array<Schema.suspend<$Representation>>;
-    readonly checks: Schema.$Array<Schema.Codec<Check<{
-        readonly _tag: "isDateValid";
-    } | {
-        readonly _tag: "isGreaterThanDate";
-        readonly exclusiveMinimum: Date;
-    } | {
-        readonly _tag: "isGreaterThanOrEqualToDate";
-        readonly minimum: Date;
-    } | {
-        readonly _tag: "isLessThanDate";
-        readonly exclusiveMaximum: Date;
-    } | {
-        readonly _tag: "isLessThanOrEqualToDate";
-        readonly maximum: Date;
-    } | {
-        readonly _tag: "isBetweenDate";
-        readonly minimum: Date;
-        readonly maximum: Date;
-        readonly exclusiveMinimum?: boolean | undefined;
-        readonly exclusiveMaximum?: boolean | undefined;
-    } | {
-        readonly _tag: "isMinSize";
-        readonly minSize: number;
-    } | {
-        readonly _tag: "isMaxSize";
-        readonly maxSize: number;
-    } | {
-        readonly _tag: "isSizeBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-    }>, Check<{
-        readonly _tag: "isDateValid";
-    } | {
-        readonly _tag: "isGreaterThanDate";
-        readonly exclusiveMinimum: Date;
-    } | {
-        readonly _tag: "isGreaterThanOrEqualToDate";
-        readonly minimum: Date;
-    } | {
-        readonly _tag: "isLessThanDate";
-        readonly exclusiveMaximum: Date;
-    } | {
-        readonly _tag: "isLessThanOrEqualToDate";
-        readonly maximum: Date;
-    } | {
-        readonly _tag: "isBetweenDate";
-        readonly minimum: Date;
-        readonly maximum: Date;
-        readonly exclusiveMinimum?: boolean | undefined;
-        readonly exclusiveMaximum?: boolean | undefined;
-    } | {
-        readonly _tag: "isMinSize";
-        readonly minSize: number;
-    } | {
-        readonly _tag: "isMaxSize";
-        readonly maxSize: number;
-    } | {
-        readonly _tag: "isSizeBetween";
-        readonly minimum: number;
-        readonly maximum: number;
-    }>, never, never>>;
-    readonly encodedSchema: Schema.suspend<$Representation>;
-}>;
-/**
- * Schema for the {@link Suspend} representation node.
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Suspend: Schema.Struct<{
-    readonly _tag: Schema.tag<"Suspend">;
-    readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
-    readonly checks: Schema.Tuple<readonly []>;
-    readonly thunk: Schema.suspend<$Representation>;
-}>;
-/**
- * Type-level helper for the recursive {@link $Representation} codec.
- *
- * @category schemas
- * @since 4.0.0
- */
-export interface $Representation extends Schema.Codec<Representation> {
-}
-/**
- * Schema for the full {@link Representation} union. It recursively validates
- * and encodes any representation node.
+ * Use when an API such as `toCodeDocument` requires a `MultiDocument`.
  *
- * @category schemas
+ * @category transforming
  * @since 4.0.0
  */
-export declare const $Representation: $Representation;
+export declare function toMultiDocument(document: Document): MultiDocument;
 /**
- * Schema for {@link Document}.
+ * Compiles a live representation document to JSON Schema Draft 2020-12.
  *
  * **When to use**
  *
- * Use to validate or serialize a single schema representation document with
- * `Schema.decodeUnknownSync` or `Schema.encodeSync`.
+ * Use when you need JSON Schema output from a representation whose checks carry compiler annotations.
  *
  * **Gotchas**
  *
- * This codec validates document structure but does not resolve `$ref` keys
- * against `references`.
+ * Opaque declarations are represented by an unconstrained JSON Schema. Check callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
- * @see {@link DocumentFromJson} for the JSON-string codec wrapper
- * @see {@link $MultiDocument} for validating documents with multiple root representations
+ * @see {@link toJsonSchemaMultiDocument} for multiple roots sharing definitions
  *
- * @category schemas
- * @since 4.0.0
- */
-export declare const $Document: Schema.Struct<{
-    readonly representation: $Representation;
-    readonly references: Schema.$Record<Schema.String, $Representation>;
-}>;
-/**
- * Schema for {@link MultiDocument}.
- *
- * @category schemas
+ * @category transforming
  * @since 4.0.0
  */
-export declare const $MultiDocument: Schema.Struct<{
-    readonly representations: Schema.NonEmptyArray<$Representation>;
-    readonly references: Schema.$Record<Schema.String, $Representation>;
-}>;
+export declare function toJsonSchemaDocument(document: Document, options?: Schema.ToJsonSchemaOptions): JsonSchema.Document<"draft-2020-12">;
 /**
- * Converts a Schema AST into a {@link Document}.
+ * Compiles multiple live representations to a shared JSON Schema Draft 2020-12 document.
  *
  * **When to use**
  *
- * Use when you have a single Schema AST and need a schema representation
- * document.
- *
- * **Details**
- *
- * Shared/recursive sub-schemas are extracted into the `references` map.
+ * Use when several representation roots must share the same JSON Schema definitions.
  *
- * **Example** (Converting a Schema to a Document)
- *
- * ```ts
- * import { Schema, SchemaRepresentation } from "effect"
- *
- * const Person = Schema.Struct({
- *   name: Schema.String,
- *   age: Schema.Number
- * })
+ * **Gotchas**
  *
- * const doc = SchemaRepresentation.fromAST(Person.ast)
- * console.log(doc.representation._tag)
- * // "Objects"
- * ```
+ * Every definition is compiled, including definitions that are not reachable from a root.
  *
- * @see {@link Document}
- * @see {@link fromASTs}
+ * @see {@link toJsonSchemaDocument} for a single root
  *
- * @category constructors
+ * @category transforming
  * @since 4.0.0
  */
-export declare const fromAST: (ast: SchemaAST.AST) => Document;
+export declare function toJsonSchemaMultiDocument(document: MultiDocument, options?: Schema.ToJsonSchemaOptions): JsonSchema.MultiDocument<"draft-2020-12">;
 /**
- * Converts one or more Schema ASTs into a {@link MultiDocument}.
+ * Generates TypeScript source for live schema representations and their definitions.
  *
  * **When to use**
  *
- * Use when you have multiple Schema ASTs and need one schema representation
- * `MultiDocument` with shared references.
- *
- * **Details**
+ * Use when custom declarations and checks provide `toCode` callbacks and must be emitted without a central handler registry.
  *
- * All schemas share a single `references` map.
+ * **Gotchas**
  *
- * @see {@link MultiDocument}
- * @see {@link fromAST}
+ * Opaque declarations and leaf checks require `toCode` callbacks. Callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
- * @category constructors
+ * @category transforming
  * @since 4.0.0
  */
-export declare const fromASTs: (asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]) => MultiDocument;
+export declare function toCodeDocument(document: MultiDocument): CodeDocument;
 /**
- * Schema that decodes a {@link Document} from JSON and encodes it back.
+ * Projects a live single-root representation document and encodes it as JSON.
  *
  * **When to use**
  *
- * Use when you need a JSON codec for schema representation documents with
- * `Schema.decodeUnknownSync` or `Schema.encodeSync`.
+ * Use when you need a stable JSON value for storage or transport after calling `toRepresentation`.
  *
- * **Example** (Round-tripping a Document through JSON)
- *
- * ```ts
- * import { Schema, SchemaRepresentation } from "effect"
+ * **Gotchas**
  *
- * const doc = SchemaRepresentation.fromAST(Schema.String.ast)
- * const json = Schema.encodeSync(SchemaRepresentation.DocumentFromJson)(doc)
- * const back = Schema.decodeUnknownSync(SchemaRepresentation.DocumentFromJson)(json)
- * ```
+ * Generic annotations that are not JSON are omitted. Invalid persistence identities and unsupported structural values throw an `Error` containing their representation path.
  *
- * @see {@link $Document}
- * @see {@link MultiDocumentFromJson}
+ * @see {@link toRepresentation} for constructing the live document
+ * @see {@link toJsonMultiDocument} for documents with multiple roots
  *
- * @category schemas
+ * @category encoding
  * @since 4.0.0
  */
-export declare const DocumentFromJson: Schema.Codec<Document, Schema.Json>;
+export declare function toJson(document: Document): Schema.Json;
 /**
- * Schema for `MultiDocument` values encoded as JSON.
- *
- * @see {@link $MultiDocument}
- * @see {@link DocumentFromJson}
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare const MultiDocumentFromJson: Schema.Codec<MultiDocument, Schema.Json>;
-/**
- * Wraps a single {@link Document} as a {@link MultiDocument} with one
- * representation.
+ * Projects a live multi-root representation document and encodes it as JSON.
  *
  * **When to use**
  *
- * Use when you need to pass a single schema representation `Document` where an
- * API expects a `MultiDocument`.
- *
- * @see {@link Document}
- * @see {@link MultiDocument}
- *
- * @category transforming
- * @since 4.0.0
- */
-export declare function toMultiDocument(document: Document): MultiDocument;
-/**
- * A callback that handles {@link Declaration} nodes during reconstruction
- * ({@link toSchema}) or code generation ({@link toCodeDocument}).
+ * Use when you need one JSON value for multiple live roots that share a reference environment.
  *
- * **Details**
+ * **Gotchas**
  *
- * Return a value to handle the declaration. Return `undefined` to fall back to
- * default behavior, which uses `encodedSchema` for `toSchema` or the
- * `generation` annotation for `toCodeDocument`. `recur` processes child
- * representations recursively.
+ * The root order and shared reference keys are preserved, while non-JSON generic annotations are omitted.
  *
- * @see {@link toSchema}
- * @see {@link toSchemaDefaultReviver}
- * @see {@link toCodeDocument}
+ * @see {@link toRepresentations} for constructing the live multi-document
+ * @see {@link toJson} for a single-root document
  *
- * @category models
+ * @category encoding
  * @since 4.0.0
  */
-export type Reviver<T> = (declaration: Declaration, recur: (representation: Representation) => T) => T | undefined;
+export declare function toJsonMultiDocument(document: MultiDocument): Schema.Json;
 /**
- * Default {@link Reviver} for {@link toSchema} that handles built-in Effect
- * types, including Option, Result, Redacted, Cause, Exit, ReadonlyMap, HashMap,
- * ReadonlySet, Date, Duration, URL, and RegExp.
+ * Decodes a persisted single-root representation document from JSON.
  *
  * **When to use**
  *
- * Use when you need the default `options.reviver` for {@link toSchema} to
- * reconstruct runtime schemas for built-in Effect declarations.
+ * Use when reading a representation document from storage or transport before inspecting it or passing it to `fromRepresentation`.
  *
- * **Details**
+ * **Gotchas**
  *
- * The reviver returns `undefined` for unrecognized declarations, causing
- * fallback to `encodedSchema`.
+ * Invalid documents throw a schema decoding error. Decoding does not reconstruct runtime callbacks.
  *
- * @see {@link toSchema}
- * @see {@link Reviver}
+ * @see {@link toJson} for encoding a document
+ * @see {@link fromRepresentation} for reconstructing a runtime schema
+ * @see {@link fromJsonMultiDocument} for multiple roots sharing references
  *
- * @category transforming
+ * @category decoding
  * @since 4.0.0
  */
-export declare const toSchemaDefaultReviver: Reviver<Schema.Top>;
+export declare function fromJson(input: Schema.Json): Document;
 /**
- * Creates a runtime Schema from a {@link Document}.
+ * Decodes a persisted multi-root representation document from JSON.
  *
  * **When to use**
  *
- * Use when you have a serialized or computed schema representation document and
- * need a runtime Schema for decoding/encoding.
- *
- * **Details**
- *
- * Pass `options.reviver`, such as {@link toSchemaDefaultReviver}, to handle
- * {@link Declaration} nodes for types like `Date` and `Option`. Without a
- * reviver, declarations fall back to their `encodedSchema`. Circular references
- * are handled via lazy `Schema.suspend`.
+ * Use when reading multiple representation roots that share references before inspecting them or passing them to `fromRepresentations`.
  *
  * **Gotchas**
  *
- * This throws if a `$ref` is not found in `document.references`.
- *
- * **Example** (Reconstructing a Schema)
+ * Invalid documents throw a schema decoding error. Decoding does not reconstruct runtime callbacks.
  *
- * ```ts
- * import { Schema, SchemaRepresentation } from "effect"
- *
- * const doc = SchemaRepresentation.fromAST(
- *   Schema.Struct({ name: Schema.String }).ast
- * )
+ * @see {@link toJsonMultiDocument} for encoding a multi-document
+ * @see {@link fromRepresentations} for reconstructing runtime schemas
+ * @see {@link fromJson} for a single root
  *
- * const schema = SchemaRepresentation.toSchema(doc)
- * console.log(JSON.stringify(Schema.toJsonSchemaDocument(schema), null, 2))
- * ```
- *
- * @see {@link Document}
- * @see {@link Reviver}
- * @see {@link toSchemaDefaultReviver}
- *
- * @category Runtime Generation
+ * @category decoding
  * @since 4.0.0
  */
-export declare function toSchema<S extends Schema.Top = Schema.Top>(document: Document, options?: {
-    readonly reviver?: Reviver<Schema.Top> | undefined;
-}): S;
+export declare function fromJsonMultiDocument(input: Schema.Json): MultiDocument;
 /**
- * Converts a {@link Document} to a Draft 2020-12 JSON Schema document.
+ * Reconstructs a runtime schema from a representation document.
  *
  * **When to use**
  *
- * Use when you need to produce a standard JSON Schema document from a schema
- * representation `Document`.
+ * Use when you have decoded or constructed a document whose declaration and check annotations may require revivers.
  *
  * **Gotchas**
  *
- * JSON Schema generation is best-effort. Some Effect schema representation
- * semantics cannot be represented exactly in JSON Schema, and importing an
- * emitted JSON Schema may produce an equivalent approximation rather than the
- * original representation shape.
+ * Revivers are resolved locally by `id`; none are installed implicitly. Reviver results are used directly, and exceptions raised by a reviver pass through unchanged.
  *
- * **Example** (Generating JSON Schema)
+ * **Example** (Restoring a persisted schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaRepresentation } from "effect"
  *
- * const doc = SchemaRepresentation.fromAST(Schema.String.ast)
- * const jsonSchema = SchemaRepresentation.toJsonSchemaDocument(doc)
- * console.log(jsonSchema.schema.type)
- * // "string"
+ * const document = SchemaRepresentation.toRepresentation(Schema.Struct({ name: Schema.String }).ast)
+ * const persisted = SchemaRepresentation.toJson(document)
+ * const restored = SchemaRepresentation.fromJson(persisted)
+ * const schema = SchemaRepresentation.fromRepresentation(restored, { revivers: [] })
+ * const Person = Schema.make<Schema.Codec<{ readonly name: string }>>(schema.ast)
+ *
+ * Schema.decodeUnknownSync(Person)({ name: "Ada" }) // => { name: "Ada" }
  * ```
  *
- * @see {@link Document}
- * @see {@link toJsonSchemaMultiDocument}
- * @see {@link fromJsonSchemaDocument}
+ * @see {@link fromJson} for decoding a persisted document
+ * @see {@link fromRepresentations} for multiple roots sharing references
  *
  * @category transforming
  * @since 4.0.0
  */
-export declare const toJsonSchemaDocument: (document: Document, options?: Schema.ToJsonSchemaOptions) => JsonSchema.Document<"draft-2020-12">;
+export declare function fromRepresentation(document: Document, options: {
+    readonly revivers: ReadonlyArray<AnyReviver>;
+}): Schema.Top;
 /**
- * Converts a {@link MultiDocument} to a Draft 2020-12 JSON Schema
- * multi-document.
+ * Reconstructs multiple runtime schemas from a representation multi-document.
  *
  * **When to use**
  *
- * Use when you need to export related schema representation documents together
- * so shared definitions stay in multi-document JSON Schema form.
+ * Use when multiple roots must be rebuilt in one shared reference environment.
  *
  * **Gotchas**
  *
- * JSON Schema generation is best-effort. Some Effect schema representation
- * semantics cannot be represented exactly in JSON Schema, and importing an
- * emitted JSON Schema may produce equivalent approximations rather than the
- * original representation shapes.
+ * Only references reachable from a root are revived. Revivers are resolved locally by `id`; none are installed implicitly.
  *
- * @see {@link MultiDocument}
- * @see {@link toJsonSchemaDocument}
- * @see {@link fromJsonSchemaMultiDocument}
+ * @see {@link fromJsonMultiDocument} for decoding a persisted multi-document
+ * @see {@link fromRepresentation} for a single root
  *
  * @category transforming
  * @since 4.0.0
  */
-export declare const toJsonSchemaMultiDocument: (document: MultiDocument, options?: Schema.ToJsonSchemaOptions) => JsonSchema.MultiDocument<"draft-2020-12">;
-/**
- * A pair of TypeScript source strings for a schema: `runtime` is the
- * executable Schema expression, `Type` is the corresponding TypeScript type.
- *
- * @see {@link makeCode}
- * @see {@link CodeDocument}
- *
- * @category Code Generation
- * @since 4.0.0
- */
-export type Code = {
-    readonly runtime: string;
-    readonly Type: string;
-};
-/**
- * Constructs a {@link Code} value from a runtime expression string and a
- * TypeScript type string.
- *
- * @see {@link Code}
- *
- * @category Code Generation
- * @since 4.0.0
- */
-export declare function makeCode(runtime: string, Type: string): Code;
-/**
- * An auxiliary code artifact produced during code generation — a symbol
- * declaration, an enum declaration, or an import statement.
- *
- * @see {@link CodeDocument}
- * @see {@link toCodeDocument}
- *
- * @category Code Generation
- * @since 4.0.0
- */
-export type Artifact = {
-    readonly _tag: "Symbol";
-    readonly identifier: string;
-    readonly generation: Code;
-} | {
-    readonly _tag: "Enum";
-    readonly identifier: string;
-    readonly generation: Code;
-} | {
-    readonly _tag: "Import";
-    readonly importDeclaration: string;
-};
-/**
- * The output of {@link toCodeDocument}: generated TypeScript code for one or
- * more schemas plus their shared references and auxiliary artifacts.
- *
- * **Details**
- *
- * `codes` contains one {@link Code} per input representation.
- * `references.nonRecursives` contains topologically sorted non-recursive
- * definitions. `references.recursives` contains definitions involved in cycles.
- * `artifacts` contains symbols, enums, and import statements needed by the
- * code.
- *
- * @see {@link toCodeDocument}
- * @see {@link Code}
- * @see {@link Artifact}
- *
- * @category Code Generation
- * @since 4.0.0
- */
-export type CodeDocument = {
-    readonly codes: ReadonlyArray<Code>;
-    readonly references: {
-        readonly nonRecursives: ReadonlyArray<{
-            readonly $ref: string;
-            readonly code: Code;
-        }>;
-        readonly recursives: {
-            readonly [$ref: string]: Code;
-        };
-    };
-    readonly artifacts: ReadonlyArray<Artifact>;
-};
-/**
- * Generates TypeScript code strings from a {@link MultiDocument}.
- *
- * **When to use**
- *
- * Use when you need to produce source code for Effect Schema definitions from a
- * schema representation `MultiDocument`.
- *
- * **Details**
- *
- * `options.reviver` can customize code generation for {@link Declaration}
- * nodes. Return `undefined` to fall back to the default logic, which uses
- * `generation` annotations or the encoded schema. References are
- * topologically sorted so non-recursive definitions are emitted before their
- * dependents. `$ref` keys are converted to sanitized JavaScript identifiers.
- *
- * **Example** (Generating TypeScript code)
- *
- * ```ts
- * import { Schema, SchemaRepresentation } from "effect"
- *
- * const Person = Schema.Struct({
- *   name: Schema.String,
- *   age: Schema.Int
- * })
- *
- * const multi = SchemaRepresentation.toMultiDocument(
- *   SchemaRepresentation.fromAST(Person.ast)
- * )
- * const codeDoc = SchemaRepresentation.toCodeDocument(multi)
- * console.log(codeDoc.codes[0].runtime)
- * // Schema.Struct({ ... })
- * ```
- *
- * @see {@link CodeDocument}
- * @see {@link MultiDocument}
- * @see {@link Reviver}
- *
- * @category Code Generation
- * @since 4.0.0
- */
-export declare function toCodeDocument(multiDocument: MultiDocument, options?: {
-    /**
-     * The reviver can return `undefined` to indicate that the generation should be generated by the default logic
-     */
-    readonly reviver?: Reviver<Code> | undefined;
-}): CodeDocument;
+export declare function fromRepresentations(document: MultiDocument, options: {
+    readonly revivers: ReadonlyArray<AnyReviver>;
+}): readonly [Schema.Top, ...Array<Schema.Top>];
 /**
- * Parses a Draft 2020-12 JSON Schema document into a {@link Document}.
+ * Imports a JSON Schema Draft 2020-12 document as a runtime schema.
  *
  * **When to use**
  *
- * Use when you need to import a Draft 2020-12 JSON Schema document into the
- * Effect schema representation system.
- *
- * **Details**
- *
- * `options.onEnter` is an optional hook called on each JSON Schema node before
- * processing, allowing pre-transformation.
+ * Use when you need to validate or transform values described by an external JSON Schema document.
  *
  * **Gotchas**
  *
- * JSON Schema import is best-effort. Some JSON Schema constructs do not map
- * exactly to Effect schema representations, and importing a schema previously
- * emitted by `toJsonSchemaDocument` may produce an equivalent approximation
- * rather than the original representation shape.
+ * Import is best-effort. Built-in declarations and checks are reconstructed with importer-owned revivers. Callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
- * This throws if a `$ref` cannot be resolved within the document's definitions.
- * Circular `$ref`s are detected and cause an error.
- *
- * @see {@link Document}
- * @see {@link toJsonSchemaDocument}
- * @see {@link fromJsonSchemaMultiDocument}
+ * @see {@link fromJsonSchemaMultiDocument} for multiple roots sharing definitions
+ * @see {@link toRepresentation} for converting the result to a representation document
  *
  * @category constructors
  * @since 4.0.0
  */
-export declare function fromJsonSchemaDocument(document: JsonSchema.Document<"draft-2020-12">, options?: {
-    readonly onEnter?: ((js: JsonSchema.JsonSchema) => JsonSchema.JsonSchema) | undefined;
-}): Document;
+export declare function fromJsonSchemaDocument(document: JsonSchema.Document<"draft-2020-12">, options?: FromJsonSchemaOptions): Schema.Top;
 /**
- * Parses a Draft 2020-12 JSON Schema multi-document into a
- * {@link MultiDocument}.
+ * Imports multiple JSON Schema Draft 2020-12 roots as runtime schemas with shared definitions.
  *
  * **When to use**
  *
- * Use when you need to import a Draft 2020-12 JSON Schema multi-document whose
- * schemas share definitions.
- *
- * **Details**
- *
- * `options.onEnter` is an optional hook called on each JSON Schema node before
- * processing.
+ * Use when multiple imported roots share reachable definitions, aliases, or recursion.
  *
  * **Gotchas**
  *
- * JSON Schema import is best-effort. Some JSON Schema constructs do not map
- * exactly to Effect schema representations, and importing schemas previously
- * emitted by `toJsonSchemaMultiDocument` may produce equivalent approximations
- * rather than the original representation shapes.
- *
- * This throws if a `$ref` cannot be resolved.
+ * Only definitions reachable from a root are translated. Callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
- * @see {@link MultiDocument}
- * @see {@link toJsonSchemaMultiDocument}
- * @see {@link fromJsonSchemaDocument}
+ * @see {@link fromJsonSchemaDocument} for a single root
+ * @see {@link toRepresentations} for converting the returned schema ASTs to a representation document
  *
  * @category constructors
  * @since 4.0.0
  */
-export declare function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"draft-2020-12">, options?: {
-    readonly onEnter?: ((js: JsonSchema.JsonSchema) => JsonSchema.JsonSchema) | undefined;
-}): MultiDocument;
+export declare function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"draft-2020-12">, options?: FromJsonSchemaOptions): readonly [Schema.Top, ...Array<Schema.Top>];
+export {};
 //# sourceMappingURL=SchemaRepresentation.d.ts.map