effect 4.0.0-rc.111 → 4.0.0-rc.113

package/dist/SchemaRepresentation.js

@@ -6,35 +6,1349 @@
 import * as InternalRecord from "./internal/record.js";
 import * as InternalFromJsonSchemaDocument from "./internal/schema/fromJsonSchemaDocument.js";
 import * as InternalFromRepresentation from "./internal/schema/fromRepresentation.js";
-import * as InternalSchema from "./internal/schema/schema.js";
 import * as InternalToCodeDocument from "./internal/schema/toCodeDocument.js";
 import * as InternalToJsonSchemaDocument from "./internal/schema/toJsonSchemaDocument.js";
 import * as InternalToRepresentation from "./internal/schema/toRepresentation.js";
 import * as Option from "./Option.js";
 import * as Schema from "./Schema.js";
 import * as SchemaAST from "./SchemaAST.js";
-import * as SchemaGetter from "./SchemaGetter.js";
+import * as InternalGetter from "./SchemaGetter.js";
 /**
  * Creates a declaration reviver while inferring its payload type from `payloadSchema`.
  *
  * @category constructors
  * @since 4.0.0
  */
-export const makeDeclarationReviver = InternalSchema.makeDeclarationReviver;
+export const makeReviverDeclaration = (id, payloadSchema, revive) => ({
+  id,
+  payloadSchema,
+  revive
+});
+/**
+ * Creates a filter reviver while inferring its payload type from `payloadSchema`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const makeReviverFilter = (id, payloadSchema, revive) => ({
+  id,
+  payloadSchema,
+  revive
+});
+/**
+ * Creates a filter group reviver while inferring its payload type from `payloadSchema`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const makeReviverFilterGroup = (id, payloadSchema, revive) => ({
+  id,
+  payloadSchema,
+  revive
+});
+function makeFixedDeclarationReviver(id, schema) {
+  return makeReviverDeclaration(id, Schema.Null, ({
+    annotations
+  }) => annotations === undefined ? schema : schema.annotate(annotations));
+}
+const IsPatternPayload = /*#__PURE__*/Schema.Struct({
+  source: Schema.String,
+  flags: Schema.String
+}).check(/*#__PURE__*/Schema.makeFilter(payload => {
+  try {
+    const regExp = new globalThis.RegExp(payload.source, payload.flags);
+    return regExp.source === payload.source && regExp.flags === payload.flags;
+  } catch {
+    return false;
+  }
+}));
+const ErrorOptionsPayload = /*#__PURE__*/Schema.declare(input => {
+  if (typeof input !== "object" || input === null) return false;
+  const object = input;
+  const keys = globalThis.Object.keys(input);
+  return keys.length > 0 && keys.every(key => (key === "includeStack" || key === "excludeCause") && object[key] === true);
+});
+const ErrorRepresentationPayload = /*#__PURE__*/Schema.Union([Schema.Null, ErrorOptionsPayload]);
+const RedactedOptionsPayload = /*#__PURE__*/Schema.declare(input => {
+  if (typeof input !== "object" || input === null) return false;
+  const object = input;
+  const keys = globalThis.Object.keys(input);
+  return keys.length > 0 && keys.every(key => {
+    switch (key) {
+      case "label":
+        return typeof object[key] === "string";
+      case "disallowJsonEncode":
+        return object[key] === true;
+      default:
+        return false;
+    }
+  });
+});
+const RedactedRepresentationPayload = /*#__PURE__*/Schema.Union([Schema.Null, RedactedOptionsPayload]);
+/**
+ * Reviver for persisted `isTrimmed` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isTrimmed}.
+ *
+ * @see {@link Schema.isTrimmed} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isTrimmedReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isTrimmed", Schema.Null, ({
+  annotations
+}) => Schema.isTrimmed(annotations));
+/**
+ * Reviver for persisted `isPattern` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isPattern}.
+ *
+ * @see {@link Schema.isPattern} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isPatternReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isPattern", IsPatternPayload, ({
+  annotations,
+  payload
+}) => Schema.isPattern(new globalThis.RegExp(payload.source, payload.flags), annotations));
+/**
+ * Reviver for persisted `isStringFinite` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isStringFinite}.
+ *
+ * @see {@link Schema.isStringFinite} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isStringFiniteReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isStringFinite", Schema.Null, ({
+  annotations
+}) => Schema.isStringFinite(annotations));
+/**
+ * Reviver for persisted `isStringBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isStringBigInt}.
+ *
+ * @see {@link Schema.isStringBigInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isStringBigIntReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isStringBigInt", Schema.Null, ({
+  annotations
+}) => Schema.isStringBigInt(annotations));
+/**
+ * Reviver for persisted `isStringSymbol` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isStringSymbol}.
+ *
+ * @see {@link Schema.isStringSymbol} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isStringSymbolReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isStringSymbol", Schema.Null, ({
+  annotations
+}) => Schema.isStringSymbol(annotations));
+/**
+ * Reviver for persisted `isUUID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUUID}.
+ *
+ * @see {@link Schema.isUUID} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUUIDReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isUUID", /*#__PURE__*/Schema.Struct({
+  version: /*#__PURE__*/Schema.Union([/*#__PURE__*/Schema.Literals([1, 2, 3, 4, 5, 6, 7, 8]), Schema.Null])
+}), ({
+  annotations,
+  payload
+}) => Schema.isUUID(payload.version ?? undefined, annotations));
+/**
+ * Reviver for persisted `isGUID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGUID}.
+ *
+ * @see {@link Schema.isGUID} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGUIDReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isGUID", Schema.Null, ({
+  annotations
+}) => Schema.isGUID(annotations));
+/**
+ * Reviver for persisted `isULID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isULID}.
+ *
+ * @see {@link Schema.isULID} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isULIDReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isULID", Schema.Null, ({
+  annotations
+}) => Schema.isULID(annotations));
+/**
+ * Reviver for persisted `isBase64` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBase64}.
+ *
+ * @see {@link Schema.isBase64} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isBase64Reviver = /*#__PURE__*/makeReviverFilter("effect/schema/isBase64", Schema.Null, ({
+  annotations
+}) => Schema.isBase64(annotations));
+/**
+ * Reviver for persisted `isBase64Url` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBase64Url}.
+ *
+ * @see {@link Schema.isBase64Url} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isBase64UrlReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isBase64Url", Schema.Null, ({
+  annotations
+}) => Schema.isBase64Url(annotations));
+/**
+ * Reviver for persisted `isStartsWith` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isStartsWith}.
+ *
+ * @see {@link Schema.isStartsWith} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isStartsWithReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isStartsWith", /*#__PURE__*/Schema.Struct({
+  startsWith: Schema.String
+}), ({
+  annotations,
+  payload
+}) => Schema.isStartsWith(payload.startsWith, annotations));
+/**
+ * Reviver for persisted `isEndsWith` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isEndsWith}.
+ *
+ * @see {@link Schema.isEndsWith} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isEndsWithReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isEndsWith", /*#__PURE__*/Schema.Struct({
+  endsWith: Schema.String
+}), ({
+  annotations,
+  payload
+}) => Schema.isEndsWith(payload.endsWith, annotations));
+/**
+ * Reviver for persisted `isIncludes` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isIncludes}.
+ *
+ * @see {@link Schema.isIncludes} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isIncludesReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isIncludes", /*#__PURE__*/Schema.Struct({
+  includes: Schema.String
+}), ({
+  annotations,
+  payload
+}) => Schema.isIncludes(payload.includes, annotations));
+/**
+ * Reviver for persisted `isUppercased` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUppercased}.
+ *
+ * @see {@link Schema.isUppercased} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUppercasedReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isUppercased", Schema.Null, ({
+  annotations
+}) => Schema.isUppercased(annotations));
+/**
+ * Reviver for persisted `isLowercased` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLowercased}.
+ *
+ * @see {@link Schema.isLowercased} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLowercasedReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isLowercased", Schema.Null, ({
+  annotations
+}) => Schema.isLowercased(annotations));
+/**
+ * Reviver for persisted `isCapitalized` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isCapitalized}.
+ *
+ * @see {@link Schema.isCapitalized} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isCapitalizedReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isCapitalized", Schema.Null, ({
+  annotations
+}) => Schema.isCapitalized(annotations));
+/**
+ * Reviver for persisted `isUncapitalized` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUncapitalized}.
+ *
+ * @see {@link Schema.isUncapitalized} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUncapitalizedReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isUncapitalized", Schema.Null, ({
+  annotations
+}) => Schema.isUncapitalized(annotations));
+/**
+ * Reviver for persisted `isFinite` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isFinite}.
+ *
+ * @see {@link Schema.isFinite} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isFiniteReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isFinite", Schema.Null, ({
+  annotations
+}) => Schema.isFinite(annotations));
+/**
+ * Reviver for persisted `isGreaterThan` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThan}.
+ *
+ * @see {@link Schema.isGreaterThan} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGreaterThanReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isGreaterThan", /*#__PURE__*/Schema.Struct({
+  exclusiveMinimum: Schema.Finite
+}), ({
+  annotations,
+  payload
+}) => Schema.isGreaterThan(payload.exclusiveMinimum, annotations));
+/**
+ * Reviver for persisted `isGreaterThanOrEqualTo` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanOrEqualTo}.
+ *
+ * @see {@link Schema.isGreaterThanOrEqualTo} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGreaterThanOrEqualToReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isGreaterThanOrEqualTo", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.Finite
+}), ({
+  annotations,
+  payload
+}) => Schema.isGreaterThanOrEqualTo(payload.minimum, annotations));
+/**
+ * Reviver for persisted `isLessThan` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThan}.
+ *
+ * @see {@link Schema.isLessThan} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLessThanReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isLessThan", /*#__PURE__*/Schema.Struct({
+  exclusiveMaximum: Schema.Finite
+}), ({
+  annotations,
+  payload
+}) => Schema.isLessThan(payload.exclusiveMaximum, annotations));
+/**
+ * Reviver for persisted `isLessThanOrEqualTo` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanOrEqualTo}.
+ *
+ * @see {@link Schema.isLessThanOrEqualTo} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLessThanOrEqualToReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isLessThanOrEqualTo", /*#__PURE__*/Schema.Struct({
+  maximum: Schema.Finite
+}), ({
+  annotations,
+  payload
+}) => Schema.isLessThanOrEqualTo(payload.maximum, annotations));
+/**
+ * Reviver for persisted `isBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBetween}.
+ *
+ * @see {@link Schema.isBetween} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isBetweenReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isBetween", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.Finite,
+  maximum: Schema.Finite,
+  exclusiveMinimum: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Literal(true)),
+  exclusiveMaximum: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Literal(true))
+}), ({
+  annotations,
+  payload
+}) => Schema.isBetween(payload, annotations));
+/**
+ * Reviver for persisted `isMultipleOf` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMultipleOf}.
+ *
+ * @see {@link Schema.isMultipleOf} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMultipleOfReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isMultipleOf", /*#__PURE__*/Schema.Struct({
+  divisor: Schema.Finite
+}), ({
+  annotations,
+  payload
+}) => Schema.isMultipleOf(payload.divisor, annotations));
+/**
+ * Reviver for persisted `isInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isInt}.
+ *
+ * @see {@link Schema.isInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isIntReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isInt", Schema.Null, ({
+  annotations
+}) => Schema.isInt(annotations));
+/**
+ * Reviver for persisted `isMinLength` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMinLength}.
+ *
+ * @see {@link Schema.isMinLength} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMinLengthReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isMinLength", /*#__PURE__*/Schema.Struct({
+  minLength: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isMinLength(payload.minLength, annotations));
+/**
+ * Reviver for persisted `isMaxLength` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMaxLength}.
+ *
+ * @see {@link Schema.isMaxLength} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMaxLengthReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isMaxLength", /*#__PURE__*/Schema.Struct({
+  maxLength: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isMaxLength(payload.maxLength, annotations));
+/**
+ * Reviver for persisted `isLengthBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLengthBetween}.
+ *
+ * @see {@link Schema.isLengthBetween} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLengthBetweenReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isLengthBetween", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.Natural,
+  maximum: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isLengthBetween(payload.minimum, payload.maximum, annotations));
+/**
+ * Reviver for persisted `isMinSize` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMinSize}.
+ *
+ * @see {@link Schema.isMinSize} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMinSizeReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isMinSize", /*#__PURE__*/Schema.Struct({
+  minSize: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isMinSize(payload.minSize, annotations));
+/**
+ * Reviver for persisted `isMaxSize` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMaxSize}.
+ *
+ * @see {@link Schema.isMaxSize} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMaxSizeReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isMaxSize", /*#__PURE__*/Schema.Struct({
+  maxSize: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isMaxSize(payload.maxSize, annotations));
+/**
+ * Reviver for persisted `isSizeBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isSizeBetween}.
+ *
+ * @see {@link Schema.isSizeBetween} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isSizeBetweenReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isSizeBetween", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.Natural,
+  maximum: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isSizeBetween(payload.minimum, payload.maximum, annotations));
+/**
+ * Reviver for persisted `isMinProperties` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMinProperties}.
+ *
+ * @see {@link Schema.isMinProperties} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMinPropertiesReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isMinProperties", /*#__PURE__*/Schema.Struct({
+  minProperties: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isMinProperties(payload.minProperties, annotations));
+/**
+ * Reviver for persisted `isMaxProperties` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMaxProperties}.
+ *
+ * @see {@link Schema.isMaxProperties} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMaxPropertiesReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isMaxProperties", /*#__PURE__*/Schema.Struct({
+  maxProperties: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isMaxProperties(payload.maxProperties, annotations));
+/**
+ * Reviver for persisted `isPropertiesLengthBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isPropertiesLengthBetween}.
+ *
+ * @see {@link Schema.isPropertiesLengthBetween} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isPropertiesLengthBetweenReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isPropertiesLengthBetween", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.Natural,
+  maximum: Schema.Natural
+}), ({
+  annotations,
+  payload
+}) => Schema.isPropertiesLengthBetween(payload.minimum, payload.maximum, annotations));
+/**
+ * Reviver for persisted `isPropertyNames` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isPropertyNames}.
+ *
+ * @see {@link Schema.isPropertyNames} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isPropertyNamesReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isPropertyNames", Schema.Null, ({
+  annotations,
+  schemas
+}) => Schema.isPropertyNames(schemas[0], annotations));
+/**
+ * Reviver for persisted `isUnique` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUnique}.
+ *
+ * @see {@link Schema.isUnique} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUniqueReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isUnique", Schema.Null, ({
+  annotations
+}) => Schema.isUnique(annotations));
+/**
+ * Reviver for persisted `isUniqueKey` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUniqueKey}.
+ *
+ * @see {@link Schema.isUniqueKey} for creating the corresponding check
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUniqueKeyReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isUniqueKey", Schema.Null, ({
+  annotations
+}) => Schema.isUniqueKey(annotations));
+/**
+ * Reviver for persisted `Option` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Option}.
+ *
+ * @see {@link Schema.Option} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const OptionReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/Option", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.Option(typeParameters[0]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted {@link Schema.Result} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Result}.
+ *
+ * @see {@link Schema.Result} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ResultReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/Result", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.Result(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted {@link Schema.Redacted} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Redacted}.
+ *
+ * @see {@link Schema.Redacted} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const RedactedReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/Redacted", RedactedRepresentationPayload, ({
+  annotations,
+  payload,
+  typeParameters
+}) => {
+  const schema = Schema.Redacted(typeParameters[0], payload ?? undefined);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted `CauseReason` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.CauseReason}.
+ *
+ * @see {@link Schema.CauseReason} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const CauseReasonReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/CauseReason", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.CauseReason(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted `Cause` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Cause}.
+ *
+ * @see {@link Schema.Cause} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const CauseReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/Cause", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.Cause(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted {@link Schema.ErrorInstance} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.ErrorInstance}.
+ *
+ * @see {@link Schema.ErrorInstance} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ErrorInstanceReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/Error", ErrorRepresentationPayload, ({
+  annotations,
+  payload
+}) => {
+  const schema = Schema.ErrorInstance(payload ?? undefined);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted `Exit` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Exit}.
+ *
+ * @see {@link Schema.Exit} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ExitReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/Exit", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted {@link Schema.ReadonlyMap} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.ReadonlyMap}.
+ *
+ * @see {@link Schema.ReadonlyMap} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ReadonlyMapReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/ReadonlyMap", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.ReadonlyMap(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
- * Creates a filter reviver while inferring its payload type from `payloadSchema`.
+ * Reviver for persisted {@link Schema.Graph} declarations.
  *
- * @category constructors
+ * @category schemas
  * @since 4.0.0
  */
-export const makeFilterReviver = InternalSchema.makeFilterReviver;
+export const GraphReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/Graph", /*#__PURE__*/Schema.Literals(["directed", "undirected"]), ({
+  annotations,
+  payload,
+  typeParameters
+}) => {
+  const schema = Schema.Graph(payload, typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
- * Creates a filter group reviver while inferring its payload type from `payloadSchema`.
+ * Reviver for persisted `HashMap` declarations.
  *
- * @category constructors
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.HashMap}.
+ *
+ * @see {@link Schema.HashMap} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HashMapReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/HashMap", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.HashMap(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted {@link Schema.ReadonlySet} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.ReadonlySet}.
+ *
+ * @see {@link Schema.ReadonlySet} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ReadonlySetReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/ReadonlySet", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.ReadonlySet(typeParameters[0]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted `HashSet` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.HashSet}.
+ *
+ * @see {@link Schema.HashSet} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HashSetReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/HashSet", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.HashSet(typeParameters[0]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted {@link Schema.Chunk} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Chunk}.
+ *
+ * @see {@link Schema.Chunk} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ChunkReviver = /*#__PURE__*/makeReviverDeclaration("effect/schema/Chunk", Schema.Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Schema.Chunk(typeParameters[0]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+/**
+ * Reviver for persisted `RegExp` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.RegExp} schema.
+ *
+ * @see {@link Schema.RegExp} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const RegExpReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/RegExp", Schema.RegExp);
+/**
+ * Reviver for persisted `URL` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.URL} schema.
+ *
+ * @see {@link Schema.URL} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const URLReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/URL", Schema.URL);
+/**
+ * Reviver for persisted `Date` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.Date} schema.
+ *
+ * @see {@link Schema.Date} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DateReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/Date", Schema.Date);
+/**
+ * Reviver for persisted {@link Schema.Duration} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.Duration} schema.
+ *
+ * @see {@link Schema.Duration} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DurationReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/Duration", Schema.Duration);
+/**
+ * Reviver for persisted {@link Schema.ByteSize} declarations.
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ByteSizeReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/ByteSize", Schema.ByteSize);
+/**
+ * Reviver for persisted {@link Schema.BigDecimal} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.BigDecimal} schema.
+ *
+ * @see {@link Schema.BigDecimal} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const BigDecimalReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/BigDecimal", Schema.BigDecimal);
+/**
+ * Reviver for persisted `File` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.File} schema.
+ *
+ * @see {@link Schema.File} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const FileReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/File", Schema.File);
+/**
+ * Reviver for persisted `FormData` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.FormData} schema.
+ *
+ * @see {@link Schema.FormData} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const FormDataReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/FormData", Schema.FormData);
+/**
+ * Reviver for persisted `URLSearchParams` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.URLSearchParams} schema.
+ *
+ * @see {@link Schema.URLSearchParams} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const URLSearchParamsReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/URLSearchParams", Schema.URLSearchParams);
+/**
+ * Reviver for persisted `Uint8Array` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.Uint8Array} schema.
+ *
+ * @see {@link Schema.Uint8Array} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const Uint8ArrayReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/Uint8Array", Schema.Uint8Array);
+/**
+ * Reviver for persisted {@link Schema.DateTimeUtc} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.DateTimeUtc} schema.
+ *
+ * @see {@link Schema.DateTimeUtc} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DateTimeUtcReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/DateTimeUtc", Schema.DateTimeUtc);
+/**
+ * Reviver for persisted {@link Schema.TimeZoneOffset} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.TimeZoneOffset} schema.
+ *
+ * @see {@link Schema.TimeZoneOffset} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const TimeZoneOffsetReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/TimeZoneOffset", Schema.TimeZoneOffset);
+/**
+ * Reviver for persisted {@link Schema.TimeZoneNamed} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.TimeZoneNamed} schema.
+ *
+ * @see {@link Schema.TimeZoneNamed} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const TimeZoneNamedReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/TimeZoneNamed", Schema.TimeZoneNamed);
+/**
+ * Reviver for persisted {@link Schema.TimeZone} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.TimeZone} schema.
+ *
+ * @see {@link Schema.TimeZone} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const TimeZoneReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/TimeZone", Schema.TimeZone);
+/**
+ * Reviver for persisted {@link Schema.DateTimeZoned} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.DateTimeZoned} schema.
+ *
+ * @see {@link Schema.DateTimeZoned} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DateTimeZonedReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/DateTimeZoned", Schema.DateTimeZoned);
+/**
+ * Reviver for persisted `isGreaterThanDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanDate}.
+ *
+ * @see {@link Schema.isGreaterThanDate} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGreaterThanDateReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isGreaterThanDate", /*#__PURE__*/Schema.Struct({
+  exclusiveMinimum: Schema.Date
+}), ({
+  annotations,
+  payload
+}) => Schema.isGreaterThanDate(payload.exclusiveMinimum, annotations));
+/**
+ * Reviver for persisted `isGreaterThanOrEqualToDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanOrEqualToDate}.
+ *
+ * @see {@link Schema.isGreaterThanOrEqualToDate} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGreaterThanOrEqualToDateReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isGreaterThanOrEqualToDate", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.Date
+}), ({
+  annotations,
+  payload
+}) => Schema.isGreaterThanOrEqualToDate(payload.minimum, annotations));
+/**
+ * Reviver for persisted `isLessThanDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanDate}.
+ *
+ * @see {@link Schema.isLessThanDate} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLessThanDateReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isLessThanDate", /*#__PURE__*/Schema.Struct({
+  exclusiveMaximum: Schema.Date
+}), ({
+  annotations,
+  payload
+}) => Schema.isLessThanDate(payload.exclusiveMaximum, annotations));
+/**
+ * Reviver for persisted `isLessThanOrEqualToDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanOrEqualToDate}.
+ *
+ * @see {@link Schema.isLessThanOrEqualToDate} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLessThanOrEqualToDateReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isLessThanOrEqualToDate", /*#__PURE__*/Schema.Struct({
+  maximum: Schema.Date
+}), ({
+  annotations,
+  payload
+}) => Schema.isLessThanOrEqualToDate(payload.maximum, annotations));
+/**
+ * Reviver for persisted `isBetweenDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBetweenDate}.
+ *
+ * @see {@link Schema.isBetweenDate} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isBetweenDateReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isBetweenDate", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.Date,
+  maximum: Schema.Date,
+  exclusiveMinimum: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Literal(true)),
+  exclusiveMaximum: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Literal(true))
+}), ({
+  annotations,
+  payload
+}) => Schema.isBetweenDate(payload, annotations));
+/**
+ * Reviver for persisted `isGreaterThanBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanBigInt}.
+ *
+ * @see {@link Schema.isGreaterThanBigInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGreaterThanBigIntReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isGreaterThanBigInt", /*#__PURE__*/Schema.Struct({
+  exclusiveMinimum: Schema.BigInt
+}), ({
+  annotations,
+  payload
+}) => Schema.isGreaterThanBigInt(payload.exclusiveMinimum, annotations));
+/**
+ * Reviver for persisted `isGreaterThanOrEqualToBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanOrEqualToBigInt}.
+ *
+ * @see {@link Schema.isGreaterThanOrEqualToBigInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGreaterThanOrEqualToBigIntReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isGreaterThanOrEqualToBigInt", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.BigInt
+}), ({
+  annotations,
+  payload
+}) => Schema.isGreaterThanOrEqualToBigInt(payload.minimum, annotations));
+/**
+ * Reviver for persisted `isLessThanBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanBigInt}.
+ *
+ * @see {@link Schema.isLessThanBigInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLessThanBigIntReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isLessThanBigInt", /*#__PURE__*/Schema.Struct({
+  exclusiveMaximum: Schema.BigInt
+}), ({
+  annotations,
+  payload
+}) => Schema.isLessThanBigInt(payload.exclusiveMaximum, annotations));
+/**
+ * Reviver for persisted `isLessThanOrEqualToBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanOrEqualToBigInt}.
+ *
+ * @see {@link Schema.isLessThanOrEqualToBigInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLessThanOrEqualToBigIntReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isLessThanOrEqualToBigInt", /*#__PURE__*/Schema.Struct({
+  maximum: Schema.BigInt
+}), ({
+  annotations,
+  payload
+}) => Schema.isLessThanOrEqualToBigInt(payload.maximum, annotations));
+/**
+ * Reviver for persisted `isBetweenBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBetweenBigInt}.
+ *
+ * @see {@link Schema.isBetweenBigInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isBetweenBigIntReviver = /*#__PURE__*/makeReviverFilter("effect/schema/isBetweenBigInt", /*#__PURE__*/Schema.Struct({
+  minimum: Schema.BigInt,
+  maximum: Schema.BigInt,
+  exclusiveMinimum: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Literal(true)),
+  exclusiveMaximum: /*#__PURE__*/Schema.optional(/*#__PURE__*/Schema.Literal(true))
+}), ({
+  annotations,
+  payload
+}) => Schema.isBetweenBigInt(payload, annotations));
+/**
+ * Reviver for persisted `Json` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.Json} schema.
+ *
+ * @see {@link Schema.Json} for the corresponding immutable JSON schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const JsonReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/Json", Schema.Json);
+/**
+ * Reviver for persisted `MutableJson` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.MutableJson} schema.
+ *
+ * @see {@link Schema.MutableJson} for the corresponding mutable JSON schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export const makeFilterGroupReviver = InternalSchema.makeFilterGroupReviver;
+export const MutableJsonReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/MutableJson", Schema.MutableJson);
+const jsonSchemaRevivers = [JsonReviver, isPatternReviver, isFiniteReviver, isGreaterThanReviver, isGreaterThanOrEqualToReviver, isLessThanReviver, isLessThanOrEqualToReviver, isMultipleOfReviver, isIntReviver, isMinLengthReviver, isMaxLengthReviver, isMinPropertiesReviver, isMaxPropertiesReviver, isPropertyNamesReviver, isUniqueReviver];
 /**
  * Creates generated runtime and TypeScript source strings for a schema.
  *
@@ -107,21 +1421,24 @@ export function toMultiDocument(document) {
  *
  * **Details**
  *
- * For representation documents whose validation semantics can be expressed exactly in JSON Schema, importing the
- * emitted document with {@link fromJsonSchemaDocument} reconstructs a schema that accepts the same JSON values. This
- * is a semantic round-trip guarantee; the emitted document and reconstructed representation may have different shapes.
+ * The generated document is intended for preliminary validation. JSON Schema
+ * and Effect checks do not always have identical semantics, so the Effect
+ * decoder remains the final authority. Passing JSON Schema validation does not
+ * guarantee that Effect decoding will succeed.
  *
  * **Gotchas**
  *
  * - Reference allocation is already fixed in the input `Document`. The inherited `referencePolicy` option has no effect
  *   here; pass it to {@link toRepresentation} when creating the document.
- * - Opaque declarations are represented by an unconstrained JSON Schema and are outside the exact round-trip subset.
+ * - String length, RegExp flags, decoded-object property checks, and `oneOf` can differ from Effect validation.
+ * - Opaque declarations are represented by an unconstrained JSON Schema.
  * - Check callback results are used directly, and exceptions raised by a callback pass through unchanged. Callbacks
  *   must treat their input schemas as immutable. Each returned value must be a valid JSON Schema object graph and must
- *   not be mutated after the callback returns.
+ *   not be mutated after the callback returns. The callback author is responsible for the emitted semantics.
  * - Local definition references returned by callbacks are resolved together with compiler-generated references.
- * - Effect decoding may discard excess object properties by default. Use `onExcessProperty: "error"` when comparing
- *   validation semantics with the emitted JSON Schema.
+ *   Invalid JSON Pointer URI fragments throw an `Error`.
+ * - The default `onExcessProperty: "ignore"` matches the decoder default. Use `onExcessProperty: "error"` in both
+ *   places when a closed object contract is required.
  *
  * @see {@link toJsonSchemaMultiDocument} for multiple roots sharing definitions
  *
@@ -145,7 +1462,9 @@ export function toJsonSchemaDocument(document, options) {
  * - Every definition is compiled, including definitions that are not reachable from a root. Check callbacks must treat
  *   their input schemas as immutable. Each returned value must be a valid JSON Schema object graph and must not be
  *   mutated after the callback returns. Local definition references returned by callbacks are resolved together with
- *   compiler-generated references.
+ *   compiler-generated references. Invalid JSON Pointer URI fragments throw an `Error`.
+ * - String length, RegExp flags, decoded-object property checks, `oneOf`, and custom check callbacks can differ from
+ *   Effect validation, as described by {@link toJsonSchemaDocument}.
  *
  * @see {@link toJsonSchemaDocument} for a single root
  *
@@ -192,8 +1511,8 @@ function pruneAnnotations(annotations) {
   return Object.keys(out).length === 0 ? Option.none() : Option.some(out);
 }
 const AnnotationsSchema = /*#__PURE__*/Schema.optional(Schema.Record(Schema.String, Schema.Unknown)).pipe(/*#__PURE__*/Schema.encodeTo(/*#__PURE__*/Schema.optionalKey(Schema.JsonObject), {
-  decode: /*#__PURE__*/SchemaGetter.passthroughSubtype(),
-  encode: /*#__PURE__*/SchemaGetter.transformOptional(annotations => Option.isNone(annotations) || annotations.value === undefined ? Option.none() : pruneAnnotations(annotations.value))
+  decode: /*#__PURE__*/InternalGetter.passthroughSubtype(),
+  encode: /*#__PURE__*/InternalGetter.transformOptional(annotations => Option.isNone(annotations) || annotations.value === undefined ? Option.none() : pruneAnnotations(annotations.value))
 }));
 const CheckSchema = /*#__PURE__*/Schema.suspend(() => CheckUnion);
 const ChecksSchema = /*#__PURE__*/Schema.Array(CheckSchema);
@@ -238,8 +1557,8 @@ function makeValueSchema(type, value) {
     type: Schema.tag(type),
     value
   }), {
-    decode: SchemaGetter.transform(encoded => encoded.value),
-    encode: SchemaGetter.transform(value => ({
+    decode: InternalGetter.transform(encoded => encoded.value),
+    encode: InternalGetter.transform(value => ({
       type,
       value
     }))
@@ -299,7 +1618,9 @@ const UnionSchema = /*#__PURE__*/Schema.Struct({
   _tag: /*#__PURE__*/Schema.tag("Union"),
   ...KeywordFields,
   types: RepresentationsSchema,
-  mode: /*#__PURE__*/Schema.Literals(["anyOf", "oneOf"])
+  options: /*#__PURE__*/Schema.optionalKey(/*#__PURE__*/Schema.Struct({
+    mode: /*#__PURE__*/Schema.optionalKey(/*#__PURE__*/Schema.Literals(["anyOf", "oneOf"]))
+  }))
 });
 const ReferenceSchema = /*#__PURE__*/Schema.Struct({
   _tag: /*#__PURE__*/Schema.tag("Reference"),
@@ -470,8 +1791,18 @@ export function fromRepresentations(document, options) {
  *
  * **Gotchas**
  *
- * - Import is best-effort outside the exactly translated subset. Unsupported or ignored keywords are not covered by the
- *   round-trip guarantee.
+ * - `$dynamicRef`, `contains`, `dependentRequired`, `dependentSchemas`, `not`, active `if` / `then` / `else`,
+ *   `unevaluatedItems`, and `unevaluatedProperties` throw an `Unsupported JSON Schema keyword` error. Inactive
+ *   conditional keywords and `minContains` / `maxContains` without `contains` have no validation effect and are ignored.
+ * - Objects and arrays used as `const` values or `enum` members throw an `Unsupported structured JSON Schema value`
+ *   error.
+ * - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
+ *   literal sets. Other union intersections, including cases that would duplicate a nested choice, throw an
+ *   `Unsupported intersection of overlapping unions` error.
+ * - Unknown extension keywords are ignored and their semantics are not enforced.
+ * - Only direct local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported. Root
+ *   references, external references, and pointers below a definition throw an `Unsupported reference` error. A direct
+ *   reference to a missing definition throws an `Invalid reference` error.
  * - Built-in declarations and checks are reconstructed with importer-owned revivers.
  * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
  *   documents, or `patterns: "ignore"` to weaken validation explicitly; ignored patterns are outside the round-trip
@@ -487,7 +1818,7 @@ export function fromRepresentations(document, options) {
  * @since 4.0.0
  */
 export function fromJsonSchemaDocument(document, options) {
-  return InternalFromJsonSchemaDocument.fromJsonSchemaDocument(document, options);
+  return InternalFromJsonSchemaDocument.fromJsonSchemaDocument(document, options, jsonSchemaRevivers);
 }
 /**
  * Imports multiple JSON Schema Draft 2020-12 roots as runtime schemas with shared definitions.
@@ -498,9 +1829,20 @@ export function fromJsonSchemaDocument(document, options) {
  *
  * **Gotchas**
  *
- * Only definitions reachable from a root are translated. Pattern constraints reached during translation cause an error
- * by default. Use `patterns: "apply"` only for trusted documents, or `patterns: "ignore"` to weaken validation explicitly.
- * Callback results are used directly, and exceptions raised by a callback pass through unchanged.
+ * - Only definitions reachable from a root are translated.
+ * - Unsupported standard validation and applicator keywords throw an `Unsupported JSON Schema keyword` error. Unknown
+ *   extension keywords are ignored and their semantics are not enforced.
+ * - Objects and arrays used as `const` values or `enum` members throw an `Unsupported structured JSON Schema value`
+ *   error.
+ * - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
+ *   literal sets. Other union intersections, including cases that would duplicate a nested choice, throw an
+ *   `Unsupported intersection of overlapping unions` error.
+ * - Only direct local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported. Root
+ *   references, external references, and pointers below a definition throw an `Unsupported reference` error. A direct
+ *   reference to a missing definition throws an `Invalid reference` error.
+ * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
+ *   documents, or `patterns: "ignore"` to weaken validation explicitly.
+ * - Callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
  * @see {@link fromJsonSchemaDocument} for a single root
  * @see {@link toRepresentations} for converting the returned schema ASTs to a representation document
@@ -509,6 +1851,6 @@ export function fromJsonSchemaDocument(document, options) {
  * @since 4.0.0
  */
 export function fromJsonSchemaMultiDocument(document, options) {
-  return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options);
+  return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options, jsonSchemaRevivers);
 }
 //# sourceMappingURL=SchemaRepresentation.js.map