@powerlines/schema 0.11.81 → 0.11.82

package/dist/index.d.cts

@@ -1,1896 +1,15 @@
-import { Context, PluginContext, ResolveOptions, UnresolvedContext } from "@powerlines/core";
-import { DeepPartial } from "@stryke/types/base";
-import { BuildOptions, OutputFile } from "esbuild";
-import standaloneCode from "ajv/dist/standalone/index.js";
-import { Type } from "@powerlines/deepkit/vendor/type";
-import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
-import { FileReference, FileReferenceInput } from "@stryke/types/configuration";
-import { InputObject, Schema as Schema$1 } from "untyped";
-import { BaseIssue, BaseSchema } from "valibot";
-import * as z3 from "zod/v3";
+import { BundleOptions, bundle } from "./bundle.cjs";
+import { JSON_SCHEMA_METADATA_KEYS, JSON_SCHEMA_PRIMITIVE_TYPES, JSON_SCHEMA_TYPES, JsonSchemaTypeNames, VALID_SOURCE_FILE_EXTENSIONS } from "./constants.cjs";
+import { BaseSchemaSource, ExtractedSchema, JsonSchema, JsonSchemaAllOf, JsonSchemaAny, JsonSchemaAnyOf, JsonSchemaArray, JsonSchemaBigint, JsonSchemaBoolean, JsonSchemaConditionalKeywords, JsonSchemaDate, JsonSchemaDecimal, JsonSchemaDecimalFormat, JsonSchemaEnum, JsonSchemaInteger, JsonSchemaIntegerFormat, JsonSchemaKeywords, JsonSchemaLike, JsonSchemaLiteral, JsonSchemaLogicKeywords, JsonSchemaMap, JsonSchemaMetadataKeywords, JsonSchemaNativeEnum, JsonSchemaNever, JsonSchemaNull, JsonSchemaNullable, JsonSchemaNumber, JsonSchemaNumberFormat, JsonSchemaObject, JsonSchemaPrimitiveType, JsonSchemaPrimitiveUnion, JsonSchemaRecord, JsonSchemaRecordPropertyNames, JsonSchemaRef, JsonSchemaSchemaSource, JsonSchemaSet, JsonSchemaString, JsonSchemaStringFormat, JsonSchemaTuple, JsonSchemaType, JsonSchemaUndefined, JsonSchemaUnion, JsonSchemaUnknown, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, UntypedInputObject, UntypedSchema, UntypedSchemaSource, ValibotSchema, ValibotSchemaSource, Zod3SchemaSource } from "./types.cjs";
+import { generateCode, generateParserCode, generateValidationCode, getJsonSchemaType, stringifyType, stringifyValue } from "./codegen.cjs";
+import { bundleReferences, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaWithSource, extractSource, extractVariant } from "./extract.cjs";
+import { GetPropertiesResult, addProperty, getJsonSchema, getJsonSchemaObject, getProperties, getPropertiesList, isPropertyOptional, isSchemaNullable, isValidSchemaInputFile, merge } from "./helpers.cjs";
+import { applyJsonSchemaMetadata, getPrimarySchemaType, readSchemaTypes } from "./metadata.cjs";
+import { getCacheDirectory, getCacheFilePath, readSchema, readSchemaSafe, writeSchema } from "./persistence.cjs";
+import { reflectionToJsonSchema } from "./reflection.cjs";
+import { resolve, resolveModule, resolveReflection } from "./resolve.cjs";
+import { isJsonSchema, isJsonSchemaAllOf, isJsonSchemaAny, isJsonSchemaAnyOf, isJsonSchemaArray, isJsonSchemaBigint, isJsonSchemaBoolean, isJsonSchemaDate, isJsonSchemaDecimal, isJsonSchemaEnum, isJsonSchemaInteger, isJsonSchemaKeywords, isJsonSchemaLiteral, isJsonSchemaMap, isJsonSchemaNativeEnum, isJsonSchemaNever, isJsonSchemaNull, isJsonSchemaNullable, isJsonSchemaNumber, isJsonSchemaObject, isJsonSchemaPrimitiveType, isJsonSchemaPrimitiveUnion, isJsonSchemaRecord, isJsonSchemaRef, isJsonSchemaSet, isJsonSchemaString, isJsonSchemaTuple, isJsonSchemaType, isJsonSchemaUndefined, isJsonSchemaUnion, isJsonSchemaUnknown, isNullOnlyJsonSchema, isSchema, isSchemaObject, isSchemaWithSource, isStandardSchema, isUntypedInput, isUntypedInputStrict, isUntypedSchema, isUntypedSchemaStrict, isValibotSchema } from "./type-checks.cjs";
 
-//#region src/bundle.d.ts
-type BundleOptions = DeepPartial<BuildOptions> & {
-  name?: string;
-  resolve?: DeepPartial<ResolveOptions>;
-};
-/**
- * Bundle a type definition to a module.
- *
- * @param context - The context object containing the environment paths.
- * @param file - The file path to bundle.
- * @param options - Optional overrides for the ESBuild configuration.
- * @returns A promise that resolves to the bundled module.
- */
-declare function bundle<TContext extends UnresolvedContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputFile>;
-//#endregion
-//#region src/constants.d.ts
-declare const VALID_SOURCE_FILE_EXTENSIONS: string[];
-declare const JsonSchemaTypeNames: {
-  readonly STRING: "string";
-  readonly NUMBER: "number";
-  readonly INTEGER: "integer";
-  readonly BOOLEAN: "boolean";
-  readonly NULL: "null";
-  readonly OBJECT: "object";
-  readonly ARRAY: "array";
-};
-declare const JSON_SCHEMA_PRIMITIVE_TYPES: readonly ["string", "number", "integer", "boolean", "null"];
-declare const JSON_SCHEMA_TYPES: readonly ["string", "number", "integer", "boolean", "null", "array", "object"];
-declare const JSON_SCHEMA_METADATA_KEYS: ("title" | "description" | "docs" | "examples" | "alias" | "tags" | "deprecated" | "hidden" | "ignore" | "internal" | "runtime" | "readOnly" | "writeOnly")[];
-//#endregion
-//#region src/types.d.ts
-/**
- * Alias for the Untyped object-input schema shape.
- */
-type UntypedInputObject = InputObject;
-/**
- * Alias for the Untyped schema document shape.
- */
-type UntypedSchema = Schema$1;
-/**
- * A Valibot schema instance.
- *
- * @template TInput - The raw input type accepted by the schema.
- * @template TOutput - The parsed output type produced by the schema.
- * @template TIssue - The issue type emitted for validation errors.
- */
-type ValibotSchema<TInput = unknown, TOutput = unknown, TIssue extends BaseIssue<unknown> = BaseIssue<unknown>> = BaseSchema<TInput, TOutput, TIssue>;
-/**
- * Primitive JSON Schema `type` keyword values.
- *
- * @see https://json-schema.org/draft/2020-12/json-schema-core#section-7.6.1
- */
-type JsonSchemaPrimitiveType = (typeof JSON_SCHEMA_PRIMITIVE_TYPES)[number];
-/**
- * JSON Schema type names for the `type` keyword.
- *
- * @see https://json-schema.org/draft/2020-12/json-schema-core#section-7.6.1
- */
-type JsonSchemaType = (typeof JSON_SCHEMA_TYPES)[number];
-/**
- * Semantic format names for JSON Schema integer types.
- */
-type JsonSchemaIntegerFormat = "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32" | "int64" | "uint64";
-/**
- * Semantic format names for JSON Schema decimal types.
- */
-type JsonSchemaDecimalFormat = "float" | "double";
-/**
- * Semantic format names for JSON Schema numeric types, including both integer and decimal formats.
- */
-type JsonSchemaNumberFormat = JsonSchemaDecimalFormat | JsonSchemaIntegerFormat;
-/**
- * Semantic format names for JSON Schema string types.
- */
-type JsonSchemaStringFormat = "binary" | "date" | "time" | "date-time" | "iso-time" | "iso-date-time" | "duration" | "uri" | "uri-reference" | "uri-template" | "url" | "email" | "hostname" | "ipv4" | "ipv6" | "regex" | "uuid" | "json-pointer" | "json-pointer-uri-fragment" | "relative-json-pointer" | "byte" | "password";
-/**
- * Metadata and annotation keywords shared across JSON Schema shapes.
- *
- * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8
- */
-interface JsonSchemaMetadataKeywords {
-  /**
-   * A unique identifier keyword that is used to identify a schema and can be used for referencing the schema within other schemas. It is a URI that serves as a unique identifier for the schema.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.1
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8.2.1
-   */
-  $id?: string;
-  /**
-   * A keyword used to specify the version of the JSON Schema specification that the schema adheres to. It is a URI that indicates which version of the JSON Schema specification the schema is written against.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8.1.1
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.2
-   */
-  $schema?: string;
-  /**
-   * A keyword that is used in meta-schemas to identify the vocabularies available for use in schemas described by that meta-schema.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8.1.2
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.2
-   */
-  $vocabulary?: Record<string, boolean>;
-  /**
-   * A comment or annotation for the schema, which can be used to provide additional context or information about the schema. It allows schema authors to include human-readable explanations or notes within the schema without affecting its validation behavior.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8.3
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.3
-   */
-  $comment?: string;
-  /**
-   * A plain-name fragment identifier for the schema resource.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8.2.2
-   */
-  $anchor?: string;
-  /**
-   * The `$defs` keyword is used to define reusable sub-schemas within a JSON Schema. It allows you to define sub-schemas that can be referenced elsewhere in the schema using the `$ref` keyword. The `$defs` keyword is an object where each key is a unique identifier for the sub-schema, and the value is the sub-schema itself.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8.2.4
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.4
-   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
-   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
-   */
-  $defs?: Record<string, JsonSchema>;
-  /**
-   * The `$dynamicRef` keyword is used to reference a dynamic anchor defined in a JSON Schema. It allows you to reference a sub-schema that is determined at runtime based on the context of the validation. The value of `$dynamicRef` is a URI that points to the dynamic anchor defined using the `$dynamicAnchor` keyword.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8.2.3.2
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.6
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.7
-   */
-  $dynamicRef?: string;
-  /**
-   * The `$dynamicAnchor` keyword is used to define a dynamic anchor within a JSON Schema. A dynamic anchor is a placeholder that can be referenced using the `$dynamicRef` keyword. It allows for more flexible referencing of sub-schemas, as the actual schema that the dynamic anchor points to can be determined at runtime based on the context of the validation.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.6
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.7
-   */
-  $dynamicAnchor?: string;
-  /**
-   * A name for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable name or description for the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  name?: string;
-  /**
-   * A title for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable name or description for the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  title?: string;
-  /**
-   * A description for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable explanation or summary of the schema's purpose and usage. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  description?: string;
-  /**
-   * A URL to external documentation for the schema, which can be used by documentation tools or other libraries that support this feature to provide additional information or resources related to the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  docs?: string;
-  /**
-   * An array of example values that conform to the schema. This property can be used to provide sample data for documentation purposes or to assist developers in understanding the expected structure and content of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   */
-  examples?: unknown[];
-  /**
-   * An array of strings or an alias reference to indicate that the field is an alias for one or more other fields.
-   */
-  alias?: string[];
-  /**
-   * An array of strings indicating groups that the schema belongs to. This property can be used for organizational or categorization purposes in documentation tools or other libraries that support this feature. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  tags?: string[];
-  /**
-   * An indicator specifying if the field is deprecated or not. This property can be used by documentation tools or other libraries that support this feature to provide additional information or warnings about the usage of the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  deprecated?: boolean | string | {
-    message?: string;
-    since?: string;
-    alternative?: string;
-  };
-  /**
-   * An indicator specifying if the field should be marked as hidden or not. This property can be used by documentation tools or other libraries that support this feature to provide additional information or warnings about the usage of the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  hidden?: boolean;
-  /**
-   * An indicator specifying if the field should be ignored or not. This property can be used by documentation tools or other libraries that support this feature to provide additional information or warnings about the usage of the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  ignore?: boolean;
-  /**
-   * An indicator specifying if the field is internal or not.
-   *
-   * @internal
-   */
-  internal?: boolean;
-  /**
-   * An indicator specifying if the field should only be populated at runtime or not.
-   */
-  runtime?: boolean;
-  /**
-   * An indicator specifying if the field is read-only or not.
-   */
-  readOnly?: boolean;
-  /**
-   * An indicator specifying if the field is write-only or not. This property can be used by documentation tools or other libraries that support this feature to provide additional information or warnings about the usage of the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
-   */
-  writeOnly?: boolean;
-}
-/**
- * A keyword group corresponding to logical operators for combining or modifying the boolean assertion results of the subschemas. They have no direct impact on annotation collection, although they enable the same annotation keyword to be applied to an instance location with different values.
- *
- * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.1
- * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.5
- */
-interface JsonSchemaLogicKeywords {
-  /**
-   * A set of schemas where the data must satisfy all members.
-   *
-   * @remarks
-   * An instance validates successfully against this keyword if it validates successfully against all schemas defined by this keyword's value.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.1.1
-   */
-  allOf?: JsonSchema[];
-  /**
-   * A set of schemas where the data must satisfy at least one member.
-   *
-   * @remarks
-   * An instance validates successfully against this keyword if it validates successfully against at least one schema defined by this keyword's value. Note that when annotations are being collected, all subschemas **MUST** be examined so that annotations are collected from each subschema that validates successfully.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.1.2
-   */
-  anyOf?: JsonSchema[];
-  /**
-   * A set of schemas where the data must satisfy exactly one member.
-   *
-   * @remarks
-   * An instance validates successfully against this keyword if it validates successfully against exactly one schema defined by this keyword's value.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.1.3
-   */
-  oneOf?: JsonSchema[];
-  /**
-   * A schema that must not match the data.
-   *
-   * @remarks
-   * An instance is valid against this keyword if it fails to validate successfully against the schema defined by this keyword
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.1.4
-   */
-  not?: JsonSchema;
-}
-/**
- * A set of JSON Schema keywords that define conditional combination rules for schemas. These keywords work together to implement conditional application of a subschema based on the outcome of another subschema.
- *
- * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.2
- * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.5
- */
-interface JsonSchemaConditionalKeywords {
-  /**
-   * A schema that the data must not satisfy.
-   *
-   * @remarks
-   * Instances that successfully validate against this keyword's subschema **MUST** also be valid against the subschema value of the {@link then} keyword, if present. Instances that fail to validate against this keyword's subschema **MUST** also be valid against the subschema value of the {@link else} keyword, if present.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.2.1
-   */
-  if?: JsonSchema;
-  /**
-   * A schema applied when {@link if} matches.
-   *
-   * @remarks
-   * When {@link if} is present, and the instance successfully validates against its subschema, then validation succeeds against this keyword if the instance also successfully validates against this keyword's subschema.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.2.2
-   */
-  then?: JsonSchema;
-  /**
-   * A schema applied when {@link if} does not match.
-   *
-   * @remarks
-   * When {@link if} is present, and the instance fails to validate against its subschema, then validation succeeds against this keyword if the instance successfully validates against this keyword's subschema.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.2.3
-   */
-  else?: JsonSchema;
-}
-/**
- * Shared JSON Schema keyword groups applied to most schema variants.
- */
-type JsonSchemaKeywords = JsonSchemaMetadataKeywords & JsonSchemaLogicKeywords & JsonSchemaConditionalKeywords;
-/**
- * A schema that can point to another schema via `$ref`.
- */
-interface JsonSchemaAny extends JsonSchemaKeywords {
-  /**
-   * A URI reference to another schema.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-8.2.3.1
-   */
-  $ref?: string;
-}
-/**
- * JSON Schema keywords for array validation.
- *
- * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.1
- */
-interface JsonSchemaArray extends JsonSchemaKeywords {
-  /**
-   * Declares that the instance must be an array.
-   */
-  type: "array";
-  /**
-   * Schemas for positional items at each tuple index.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.1.1
-   */
-  prefixItems?: JsonSchema[];
-  /**
-   * Schema for array items beyond `prefixItems`, or all items when `prefixItems` is omitted.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.1.2
-   */
-  items?: JsonSchema;
-  /**
-   * A subschema that at least one array item must satisfy.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.1.3
-   */
-  contains?: JsonSchema;
-  /**
-   * Minimum number of items allowed.
-   */
-  minItems?: number;
-  /**
-   * Maximum number of items allowed.
-   */
-  maxItems?: number;
-  /**
-   * Whether all items must be unique.
-   */
-  uniqueItems?: boolean;
-  /**
-   * Minimum count of items that must satisfy `contains`.
-   */
-  minContains?: number;
-  /**
-   * Maximum count of items that may satisfy `contains`.
-   */
-  maxContains?: number;
-  /**
-   * Controls validation of array items not covered by prior applicators.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-11.2
-   */
-  unevaluatedItems?: boolean | JsonSchema;
-}
-/**
- * Integer schema specialized for 64-bit integer semantics.
- */
-interface JsonSchemaBigint extends JsonSchemaKeywords {
-  /**
-   * Declares that the instance must be an integer.
-   */
-  type: "integer";
-  /**
-   * Identifies an `int64` integer representation.
-   */
-  format: "int64";
-  /**
-   * Inclusive lower bound for valid values.
-   */
-  minimum?: bigint;
-  /**
-   * Exclusive lower bound for valid values.
-   */
-  exclusiveMinimum?: bigint;
-  /**
-   * Inclusive upper bound for valid values.
-   */
-  maximum?: bigint;
-  /**
-   * Exclusive upper bound for valid values.
-   */
-  exclusiveMaximum?: bigint;
-  /**
-   * Constraint requiring values to be divisible by this number.
-   */
-  multipleOf?: bigint;
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: bigint;
-  /**
-   * Fixed set of allowed integer values.
-   */
-  enum?: bigint[];
-}
-/**
- * Boolean schema keywords.
- */
-interface JsonSchemaBoolean extends JsonSchemaKeywords {
-  /**
-   * Declares that the instance must be a boolean.
-   */
-  type: "boolean";
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: boolean;
-}
-/**
- * Date and time schema variants.
- *
- * @remarks
- * This type supports either direct date/time format constraints or recursive unions through `anyOf`.
- *
- * @see https://json-schema.org/draft/2020-12/json-schema-validation#section-7
- */
-type JsonSchemaDate = JsonSchemaKeywords & ({
-  /**
-   * Declares the storage type used for temporal values.
-   */
-  type: "integer" | "string";
-  /**
-   * A date/time format name used for semantic validation.
-   */
-  format: "date" | "time" | "date-time" | "iso-time" | "iso-date-time" | "unix-time";
-  /**
-   * Inclusive lower bound for numeric time representations.
-   */
-  minimum?: number;
-  /**
-   * Inclusive upper bound for numeric time representations.
-   */
-  maximum?: number;
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: string | number;
-} | {
-  /**
-   * Alternative date/time schemas where at least one must match.
-   */
-  anyOf: JsonSchemaDate[];
-});
-/**
- * Enum-constrained schema.
- *
- * @template T - The literal type allowed by the enum values.
- */
-interface JsonSchemaEnum<T extends string | number | bigint | boolean | null = string | number | bigint | boolean | null> extends JsonSchemaKeywords {
-  /**
-   * Primitive type of the enum values.
-   */
-  type: JsonSchemaPrimitiveType;
-  /**
-   * The complete set of allowed literal values.
-   */
-  enum: T[];
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: T;
-}
-interface JsonSchemaAllOf extends JsonSchemaKeywords {
-  /**
-   * Subschemas that must all validate successfully.
-   */
-  allOf: JsonSchema[];
-  /**
-   * Controls validation for object properties not evaluated by prior keywords.
-   */
-  unevaluatedProperties?: boolean | JsonSchema;
-}
-/**
- * A schema that matches exactly one literal value.
- */
-interface JsonSchemaLiteral extends JsonSchemaKeywords {
-  /**
-   * Constant value that an instance must equal.
-   */
-  const: unknown;
-  /**
-   * Optional explicit type constraint for the constant.
-   */
-  type?: JsonSchemaType | JsonSchemaType[];
-}
-/**
- * Array representation for map-like entries as `[key, value]` tuples.
- */
-interface JsonSchemaMap extends JsonSchemaKeywords {
-  /**
-   * Declares that the map is represented as an array.
-   */
-  type: "array";
-  /**
-   * Maximum number of entries allowed.
-   */
-  maxItems: 125;
-  /**
-   * Tuple schema describing each map entry as `[key, value]`.
-   */
-  items: {
-    /**
-     * Declares that each entry is an array tuple.
-     */
-    type: "array";
-    /**
-     * Two-position tuple schemas for key and value.
-     */
-    prefixItems: [JsonSchema, JsonSchema];
-    /**
-     * Disallows additional tuple positions.
-     */
-    items?: false;
-    /**
-     * Minimum tuple length.
-     */
-    minItems: 2;
-    /**
-     * Maximum tuple length.
-     */
-    maxItems: 2;
-  };
-}
-/**
- * Enum schema that allows both string and numeric enum members.
- */
-interface JsonSchemaNativeEnum extends JsonSchemaKeywords {
-  /**
-   * Type domain allowed by the native enum.
-   */
-  type: "string" | "number" | ["string", "number"];
-  /**
-   * Allowed enum member values.
-   */
-  enum: (string | number)[];
-}
-/**
- * A schema that intentionally matches no values.
- */
-interface JsonSchemaNever extends JsonSchemaKeywords {
-  /**
-   * Negated schema used to make validation impossible.
-   */
-  not: JsonSchemaAny;
-}
-/**
- * Schema representing the JSON `null` literal type.
- */
-interface JsonSchemaNull extends JsonSchemaKeywords {
-  /**
-   * The JSON Schema null type. This property is used to indicate that the schema represents a null value, which is a special value in JSON that represents the absence of a value or a null reference. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   */
-  type: "null";
-  /**
-   * A constant value constrained to null when the schema is nullable.
-   */
-  const?: null;
-  /**
-   * Allowed values, including null when the schema is nullable.
-   */
-  enum?: null[];
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: null;
-}
-/**
- * Nullable schema variants that include an explicit `null` branch.
- */
-type JsonSchemaNullable = JsonSchemaKeywords & ({
-  /**
-   * Two-branch union that includes a non-null schema and explicit `null` schema.
-   */
-  anyOf: [JsonSchema, JsonSchemaNull];
-} | {
-  /**
-   * Primitive `type` tuple that explicitly includes `null`.
-   */
-  type: [Exclude<JsonSchemaType, "null">, "null"] | ["null", Exclude<JsonSchemaType, "null">];
-});
-/**
- * Numeric schema keywords for numbers and integers.
- *
- * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.2
- */
-interface JsonSchemaNumber extends JsonSchemaKeywords {
-  /**
-   * Declares whether values are numbers or integers.
-   */
-  type: "number" | "integer";
-  /**
-   * Optional semantic format for numeric values.
-   */
-  format?: JsonSchemaNumberFormat | string;
-  /**
-   * Inclusive lower bound for numeric values.
-   */
-  minimum?: number;
-  /**
-   * Exclusive lower bound for numeric values.
-   */
-  exclusiveMinimum?: number;
-  /**
-   * Inclusive upper bound for numeric values.
-   */
-  maximum?: number;
-  /**
-   * Exclusive upper bound for numeric values.
-   */
-  exclusiveMaximum?: number;
-  /**
-   * Constraint requiring values to be divisible by this value.
-   */
-  multipleOf?: number;
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: number;
-  /**
-   * Fixed set of allowed numeric values.
-   */
-  enum?: number[];
-}
-/**
- * Integer-only numeric schema.
- */
-interface JsonSchemaInteger extends JsonSchemaNumber {
-  /**
-   * Declares that values must be integers.
-   */
-  type: "integer";
-  /**
-   * Optional integer-specific format.
-   */
-  format?: JsonSchemaIntegerFormat | string;
-}
-/**
- * Floating-point numeric schema.
- */
-interface JsonSchemaDecimal extends JsonSchemaNumber {
-  /**
-   * Declares that values are non-integer numbers.
-   */
-  type: "number";
-  /**
-   * Optional floating-point format.
-   */
-  format?: JsonSchemaDecimalFormat | string;
-}
-/**
- * Object schema keywords.
- *
- * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.2
- */
-interface JsonSchemaObject extends JsonSchemaKeywords {
-  /**
-   * The JSON Schema object type. This property is used to indicate that the schema represents an object, which is a collection of key-value pairs where the keys are strings and the values can be of any type defined by the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   */
-  type: "object";
-  /**
-   * The declared object properties and their schemas. This property can be used to define the expected structure of an object, where each key represents a property name and the corresponding value is a schema that defines the expected type and constraints for that property. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.2.1
-   */
-  properties?: Record<string, JsonSchema>;
-  /**
-   * The schemas for properties whose names match the given patterns.
-   *
-   * @remarks
-   * Each property name of this object **SHOULD** be a valid regular expression, according to the [ECMA-262 regular expression dialect](https://www.ecma-international.org/ecma-262/). Each property value of this object **MUST** be a valid JSON Schema.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.2.2
-   */
-  patternProperties?: Record<string, JsonSchema>;
-  /**
-   * The schema for properties not matched by {@link properties} or {@link patternProperties}. This property can be used to allow additional properties in the object that are not explicitly defined in the {@link properties} or {@link patternProperties} keywords. The value of this property can be a boolean, where `true` allows any additional properties and `false` disallows any additional properties, or it can be a schema that defines the expected structure of the additional properties. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.2.3
-   */
-  additionalProperties?: boolean | JsonSchema;
-  /**
-   * A list of property names that are required for the object. This property can be used by validation libraries or other tools that support this feature to enforce the presence of certain properties in the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   */
-  required?: string[];
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: Record<string, unknown>;
-  /**
-   * The schema for properties that have not yet been evaluated by other object keywords. This property can be used to apply a schema to properties that are not explicitly defined in the {@link properties} or {@link patternProperties} keywords, and that have not been evaluated by any other object keywords such as {@link additionalProperties} or {@link dependencies}. The value of this property can be a boolean, where `true` allows any unevaluated properties and `false` disallows any unevaluated properties, or it can be a schema that defines the expected structure of the unevaluated properties. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   */
-  unevaluatedProperties?: boolean | JsonSchema;
-  /**
-   * A map of property-specific dependency requirements.
-   */
-  dependencies?: Record<string, string[] | JsonSchema>;
-  /**
-   * Properties that become required when the key property is present.
-   */
-  dependentRequired?: Record<string, string[]>;
-  /**
-   * Subschemas that apply when the key property is present.
-   *
-   * @remarks
-   * If the object key is a property in the instance, the entire instance must validate against the subschema. Its use is dependent on the presence of the property.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.2.2.4
-   */
-  dependentSchemas?: Record<string, JsonSchema>;
-  /**
-   * The minimum number of own properties allowed.
-   */
-  minProperties?: number;
-  /**
-   * The maximum number of own properties allowed.
-   */
-  maxProperties?: number;
-  /**
-   * An optional array of property names that are considered primary keys for the object. This property can be used by validation libraries or other tools that support this feature to provide additional validation rules or constraints for the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   */
-  primaryKey?: string[];
-  /**
-   * A name for the database schema associated with the data represented by this schema. This property can be used by documentation tools or other libraries that support this feature to provide additional context or information about the data model that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   */
-  databaseSchema?: string;
-}
-interface JsonSchemaString extends JsonSchemaKeywords {
-  /**
-   * Declares that the instance must be a string.
-   */
-  type: "string";
-  /**
-   * The minimum number of characters allowed in the string.
-   */
-  minLength?: number;
-  /**
-   * The maximum number of characters allowed in the string.
-   */
-  maxLength?: number;
-  /**
-   * A regular expression that matching strings must satisfy.
-   */
-  pattern?: string;
-  /**
-   * A format for the schema, which can be used by validation libraries or other tools that support this feature to provide additional validation or formatting rules for the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   *
-   * @see https://ajv.js.org/packages/ajv-formats.html
-   *
-   * @remarks
-   * The `format` property is a string that specifies the format of the data that the schema represents. It can be used to indicate that a string should be validated as an email address, a date-time, a URI, or any other format supported by compatible validation libraries. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   */
-  format?: JsonSchemaStringFormat | string;
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: string;
-  /**
-   * Fixed set of allowed string values.
-   */
-  enum?: string[];
-  /**
-   * A keyword used to specify the media type of the content that the schema represents. It can be used by validation libraries or other tools that support this feature to provide additional validation or processing rules for the data based on its media type. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.8
-   */
-  contentMediaType?: string;
-  /**
-   * A keyword used to specify the content encoding of the data that the schema represents. It can be used by validation libraries or other tools that support this feature to provide additional validation or processing rules for the data based on its content encoding. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.8
-   */
-  contentEncoding?: string;
-  /**
-   * A keyword used to specify a schema for the content that the schema represents. It can be used by validation libraries or other tools that support this feature to provide additional validation or processing rules for the data based on its schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-8.2.9
-   */
-  contentSchema?: string;
-}
-/**
- * Set-like array schema that enforces item uniqueness.
- */
-interface JsonSchemaSet extends JsonSchemaKeywords {
-  /**
-   * Declares that set values are serialized as arrays.
-   */
-  type: "array";
-  /**
-   * Enforces set semantics by requiring distinct elements.
-   */
-  uniqueItems: true;
-  /**
-   * Schemas for positional items at each tuple index.
-   */
-  prefixItems?: JsonSchema[];
-  /**
-   * Schema for remaining items.
-   */
-  items?: JsonSchema;
-  /**
-   * Subschema that at least one item must satisfy.
-   */
-  contains?: JsonSchema;
-  /**
-   * Minimum number of items allowed.
-   */
-  minItems?: number;
-  /**
-   * Maximum number of items allowed.
-   */
-  maxItems?: number;
-  /**
-   * Minimum number of items that must satisfy {@link JsonSchemaSet.contains | contains}.
-   */
-  minContains?: number;
-  /**
-   * Maximum number of items that may satisfy {@link JsonSchemaSet.contains | contains}.
-   */
-  maxContains?: number;
-  /**
-   * Controls validation for items not otherwise evaluated.
-   */
-  unevaluatedItems?: boolean | JsonSchema;
-}
-/**
- * Schema used to validate record keys.
- */
-type JsonSchemaRecordPropertyNames = JsonSchema;
-/**
- * Record/object schema with key constraints.
- */
-interface JsonSchemaRecord extends JsonSchemaKeywords {
-  /**
-   * Declares that the instance must be an object.
-   */
-  type: "object";
-  /**
-   * The schemas for properties whose names match the given patterns.
-   *
-   * @remarks
-   * Each property name of this object **SHOULD** be a valid regular expression, according to the [ECMA-262 regular expression dialect](https://www.ecma-international.org/ecma-262/). Each property value of this object **MUST** be a valid JSON Schema.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.2.2
-   */
-  patternProperties?: Record<string, JsonSchema>;
-  /**
-   * The schema for properties not matched by {@link properties} or {@link patternProperties}. This property can be used to allow additional properties in the object that are not explicitly defined in the `properties` or `patternProperties` keywords. The value of this property can be a boolean, where `true` allows any additional properties and `false` disallows any additional properties, or it can be a schema that defines the expected structure of the additional properties. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.2.3
-   */
-  additionalProperties?: boolean | JsonSchema;
-  /**
-   * The schema that each property name must satisfy.
-   */
-  propertyNames?: JsonSchemaRecordPropertyNames;
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: Record<string, unknown>;
-}
-/**
- * Tuple schema modeled with positional {@link JsonSchemaTuple.prefixItems | prefixItems} plus optional trailing {@link JsonSchemaTuple.items | items}.
- */
-type JsonSchemaTuple = JsonSchemaKeywords & {
-  /**
-   * Declares that tuple values are represented as arrays.
-   */
-  type: "array";
-  /**
-   * Minimum number of elements required.
-   */
-  minItems?: number;
-  /**
-   * Maximum number of elements allowed.
-   */
-  maxItems?: number;
-  /**
-   * Positional schemas for tuple elements.
-   */
-  prefixItems: JsonSchema[];
-  /**
-   * The schema applied to items beyond {@link prefixItems}. In draft 2020-12,
-   * tuple positions are modeled with {@link prefixItems}, while {@link items}
-   * applies to the remaining elements.
-   *
-   * @remarks
-   * The behavior of {@link items} without {@link prefixItems} is identical to that of the schema form of {@link items} in drafts prior to 2020-12. When {@link prefixItems} is present, the behavior of {@link items} is identical to the former {@link additionalItems} keyword.
-   *
-   * @see https://json-schema.org/draft/2020-12/json-schema-core#section-10.3.1.2
-   */
-  items?: JsonSchema;
-  /**
-   * Subschema that at least one tuple element must satisfy.
-   */
-  contains?: JsonSchema;
-  /**
-   * Whether tuple elements must be unique.
-   */
-  uniqueItems?: boolean;
-  /**
-   * Minimum number of elements that must satisfy {@link JsonSchemaTuple.contains | contains}.
-   */
-  minContains?: number;
-  /**
-   * Maximum number of elements that may satisfy {@link JsonSchemaTuple.contains | contains}.
-   */
-  maxContains?: number;
-  /**
-   * Controls validation of unevaluated tuple elements.
-   */
-  unevaluatedItems?: boolean | JsonSchema;
-};
-/**
- * Schema used to represent undefined-like semantics through negation.
- */
-interface JsonSchemaUndefined extends JsonSchemaKeywords {
-  /**
-   * Negated schema marker used to represent undefined-like semantics.
-   */
-  not: JsonSchemaAny;
-  /**
-   * A keyword that is used to specify a default value for a property in a JSON Schema. It provides a default value that can be used when an instance does not provide a value for that property.
-   *
-   * @see https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-10.2
-   */
-  default?: undefined;
-}
-/**
- * Union schema represented as either primitive type unions or `anyOf` compositions.
- */
-type JsonSchemaUnion = JsonSchemaKeywords & (JsonSchemaPrimitiveUnion | JsonSchemaAnyOf);
-/**
- * Union of primitive type combinations and enum-backed primitive unions.
- */
-type JsonSchemaPrimitiveUnion = JsonSchemaKeywords & ({
-  /**
-   * Primitive `type` or list of primitive types accepted by the union.
-   */
-  type: JsonSchemaPrimitiveType | JsonSchemaPrimitiveType[];
-} | {
-  /**
-   * Enum values that may be of different primitive types.
-   */
-  enum: (string | number | bigint | boolean | null)[];
-});
-/**
- * Permissive schema alias for unknown values.
- */
-type JsonSchemaUnknown = JsonSchemaKeywords & JsonSchemaAny;
-/**
- * `anyOf` composition schema.
- */
-interface JsonSchemaAnyOf extends JsonSchemaKeywords {
-  /**
-   * Subschemas where at least one must validate.
-   */
-  anyOf: JsonSchema[];
-}
-/**
- * A reference schema that resolves through a URI.
- */
-interface JsonSchemaRef extends JsonSchemaKeywords {
-  /**
-   * URI reference to a schema definition.
-   */
-  $ref: string;
-}
-/**
- * JSON Schema (draft 2020-12) type that can be used to validate JSON data. It is a union of all the specific JSON Schema types, as well as the metadata properties that can be included in any JSON Schema.
- *
- * @see https://json-schema.org/draft/2020-12
- * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
- */
-type JsonSchema = JsonSchemaString | JsonSchemaInteger | JsonSchemaDecimal | JsonSchemaBigint | JsonSchemaBoolean | JsonSchemaDate | JsonSchemaEnum | JsonSchemaLiteral | JsonSchemaNativeEnum | JsonSchemaNull | JsonSchemaArray | JsonSchemaObject | JsonSchemaRecord | JsonSchemaTuple | JsonSchemaUnion | JsonSchemaUndefined | JsonSchemaRef | JsonSchemaNever | JsonSchemaMap | JsonSchemaAny | JsonSchemaNullable | JsonSchemaAllOf | JsonSchemaUnknown | JsonSchemaSet;
-/**
- * An object containing common JSON Schema metadata properties that can be included in any schema type. This interface is used to define the shared metadata properties that can be present in all JSON Schema types, such as `$id`, `$schema`, `title`, `description`, and others. It serves as a base for all specific JSON Schema types, allowing them to include these common metadata properties without having to redefine them in each type.
- */
-interface JsonSchemaLike extends JsonSchemaKeywords {
-  $id?: string;
-  $schema?: string;
-  $vocabulary?: Record<string, boolean>;
-  $comment?: string;
-  $anchor?: string;
-  $defs?: Record<string, JsonSchema>;
-  $dynamicRef?: string;
-  $dynamicAnchor?: string;
-  $ref?: string;
-  name?: string;
-  title?: string;
-  description?: string;
-  docs?: string;
-  examples?: unknown[];
-  alias?: string[];
-  tags?: string[];
-  deprecated?: boolean | string | {
-    message?: string;
-    since?: string;
-    alternative?: string;
-  };
-  hidden?: boolean;
-  ignore?: boolean;
-  internal?: boolean;
-  runtime?: boolean;
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  type?: JsonSchemaType | JsonSchemaType[] | JsonSchemaPrimitiveType | JsonSchemaPrimitiveType[] | [Exclude<JsonSchemaType, "null">, "null"] | ["null", Exclude<JsonSchemaType, "null">];
-  const?: unknown;
-  enum?: (string | number | bigint | boolean | null)[];
-  format?: string;
-  default?: unknown;
-  allOf?: JsonSchema[];
-  anyOf?: JsonSchema[] | [JsonSchema, JsonSchemaNull];
-  oneOf?: JsonSchema[];
-  not?: JsonSchema;
-  if?: JsonSchema;
-  then?: JsonSchema;
-  else?: JsonSchema;
-  properties?: Record<string, JsonSchema>;
-  patternProperties?: Record<string, JsonSchema>;
-  additionalProperties?: boolean | JsonSchema;
-  required?: string[];
-  propertyNames?: JsonSchemaRecordPropertyNames;
-  dependencies?: Record<string, string[] | JsonSchema>;
-  dependentRequired?: Record<string, string[]>;
-  dependentSchemas?: Record<string, JsonSchema>;
-  minProperties?: number;
-  maxProperties?: number;
-  primaryKey?: string[];
-  databaseSchema?: string;
-  unevaluatedProperties?: boolean | JsonSchema;
-  prefixItems?: JsonSchema[];
-  items?: JsonSchema | JsonSchemaMap["items"];
-  contains?: JsonSchema;
-  minItems?: number;
-  maxItems?: number;
-  uniqueItems?: boolean;
-  minContains?: number;
-  maxContains?: number;
-  unevaluatedItems?: boolean | JsonSchema;
-  minLength?: number;
-  maxLength?: number;
-  pattern?: string;
-  contentMediaType?: string;
-  contentEncoding?: string;
-  contentSchema?: string;
-  minimum?: number | bigint;
-  exclusiveMinimum?: number | bigint;
-  maximum?: number | bigint;
-  exclusiveMaximum?: number | bigint;
-  multipleOf?: number | bigint;
-}
-/**
- * Supported source variants from which a schema can be extracted.
- */
-type SchemaSourceVariant = "standard-schema" | "json-schema" | "zod3" | "untyped" | "valibot" | "reflection";
-/**
- * Accepted schema input variants, including raw type definitions.
- */
-type SchemaInputVariant = SchemaSourceVariant | "file-reference";
-/**
- * Raw schema source input union before normalization.
- */
-type SchemaSourceInput = StandardJSONSchemaV1 | JsonSchema | z3.ZodTypeAny | UntypedInputObject | UntypedSchema | ValibotSchema | Type;
-/**
- * Any accepted schema input, including normalized schemas and references.
- */
-type SchemaInput = SchemaSourceInput | Schema | FileReferenceInput;
-/**
- * A schema extracted from a source input, normalized to JSON Schema.
- */
-interface Schema<TJsonSchema extends JsonSchema = JsonSchema> {
-  /** A stable content hash for the normalized schema. */
-  hash: string;
-  /** The source variant used to derive the normalized {@link JsonSchema}. */
-  variant: SchemaInputVariant;
-  /** The normalized schema definition. */
-  schema: TJsonSchema;
-}
-/**
- * Base metadata captured for schema source inputs.
- */
-interface BaseSchemaSource {
-  /** A stable content hash for the original source schema. */
-  hash: string;
-  /** The specific source format used for the schema input. */
-  variant: SchemaSourceVariant;
-  /** The original schema input captured before normalization. */
-  schema: SchemaSourceInput;
-}
-/**
- * Source descriptor for schemas that already use JSON Schema.
- */
-interface JsonSchemaSchemaSource extends BaseSchemaSource {
-  /** Indicates the source input already uses JSON Schema syntax. */
-  variant: "json-schema";
-  /** The original JSON Schema document. */
-  schema: JsonSchema;
-}
-/**
- * Source descriptor for Standard Schema inputs.
- */
-interface StandardSchemaSchemaSource extends BaseSchemaSource {
-  /** Indicates the source input follows the Standard Schema format. */
-  variant: "standard-schema";
-  /** The original Standard Schema document. */
-  schema: StandardJSONSchemaV1;
-}
-/**
- * Source descriptor for Zod v3 schema inputs.
- */
-interface Zod3SchemaSource extends BaseSchemaSource {
-  /** Indicates the source input is a Zod v3 schema. */
-  variant: "zod3";
-  /** The original Zod v3 schema instance. */
-  schema: z3.ZodTypeAny;
-}
-/**
- * Source descriptor for Deepkit reflection type inputs.
- */
-interface ReflectionSchemaSource extends BaseSchemaSource {
-  /** Indicates the source input is a Deepkit reflection {@link Type}. */
-  variant: "reflection";
-  /** The original Deepkit reflection type. */
-  schema: Type;
-}
-/**
- * Source descriptor for Untyped schema inputs.
- */
-interface UntypedSchemaSource extends BaseSchemaSource {
-  /** Indicates the source input comes from the Untyped schema model. */
-  variant: "untyped";
-  /** The original Untyped schema input. */
-  schema: UntypedInputObject | UntypedSchema;
-}
-/**
- * Source descriptor for Valibot schema inputs.
- */
-interface ValibotSchemaSource extends BaseSchemaSource {
-  /** Indicates the source input comes from the Valibot schema model. */
-  variant: "valibot";
-  /** The original Valibot schema input. */
-  schema: ValibotSchema;
-}
-/**
- * Union of all normalized schema source descriptor variants.
- */
-type SchemaSource = JsonSchemaSchemaSource | StandardSchemaSchemaSource | Zod3SchemaSource | UntypedSchemaSource | ValibotSchemaSource | ReflectionSchemaSource;
-/**
- * A normalized schema plus metadata about the source that produced it.
- */
-interface ExtractedSchema extends Schema {
-  /**
-   * The schema source that produced this normalized schema.
-   */
-  source: SchemaSource;
-}
-//#endregion
-//#region src/codegen.d.ts
-/**
- * Stringifies a value for generated TypeScript code.
- */
-declare function stringifyValue(value?: unknown, type?: JsonSchemaType | string): string;
-/**
- * Stringifies a JSON Schema fragment into a TypeScript-like type string.
- */
-declare function stringifyType(schema?: JsonSchema): string;
-/**
- * Returns a string type representation of a value based on its type and an optional JSON Schema primitive type hint.
- *
- * @param value - The value whose type is to be represented as a string.
- * @returns A string representation of the value's type, which may be influenced by the provided JSON Schema primitive type hint. The function handles various JavaScript types and formats them accordingly, including special handling for `undefined`, `null`, booleans, numbers (with formatting), strings, objects, and arrays. If a specific type hint is provided, it will take precedence in determining the string representation of the value.
- */
-declare function getJsonSchemaType(value?: unknown): JsonSchemaType | undefined;
-/**
- * Generates standalone parser code for a JSON Schema.
- *
- * @remarks
- * The generated `parse` function reads an arbitrary input value and converts it
- * into the shape described by the schema. It walks the schema recursively to:
- *
- * - resolve local `$ref` pointers (`#/$defs/*` and `#/definitions/*`) into
- *   dedicated parser functions so recursive schemas are supported,
- * - apply `default` values for object properties (and root/array values) that
- *   are missing from the input,
- * - coerce primitive values to the declared type (for example `"42"` to `42`
- *   for an `integer` schema, or `1` to `true` for a `boolean` schema),
- * - validate `const`, `enum`, `oneOf`/`anyOf` and `allOf` constraints, and
- * - collect detailed, path-aware errors and throw a `ParserError` when the
- *   input cannot be converted into a valid value.
- *
- * @param schema - The JSON Schema to generate parser code for.
- * @returns The generated standalone parser code as a string.
- */
-declare function generateParserCode(schema: JsonSchema): string;
-/**
- * Generates standalone JSON Schema validation code using Ajv.
- *
- * @remarks
- * The generated code includes a validation function that can be used to validate data against the provided JSON Schema at runtime. The validation function will throw an error if the data does not conform to the schema, providing detailed information about the validation errors.
- *
- * @param schema - The JSON Schema to generate validation code for.
- * @param refsOrFuncts - Optional additional references or functions for Ajv's standalone code generation.
- * @returns The generated standalone validation code as a string.
- */
-declare function generateValidationCode(schema: JsonSchema, refsOrFuncts?: Parameters<typeof standaloneCode>[1]): string;
-/**
- * Generates standalone JavaScript code for validating and parsing data according to a JSON Schema.
- *
- * @remarks
- * The generated code includes:
- * - Validation code generated by Ajv for the provided JSON Schema, which can be used to validate data against the schema at runtime. The validation function will throw an error if the data does not conform to the schema, providing detailed information about the validation errors.
- * - Parsing code generated for the provided JSON Schema, which can be used to parse and validate data against the schema at runtime. The parsing function will apply default values specified in the schema if they are not present in the input data, throw an error if the input data does not conform to the schema (providing detailed information about the validation errors), and return the parsed data if it is valid according to the schema.
- *
- * @param schema - The JSON Schema to generate code for.
- * @param refsOrFuncts - Optional additional references or functions for Ajv's standalone code generation.
- * @returns The generated standalone validation and parsing code as a string.
- */
-declare function generateCode(schema: JsonSchema, refsOrFuncts?: Parameters<typeof standaloneCode>[1]): string;
-//#endregion
-//#region src/extract.d.ts
-/**
- * Bundles all external references in a JSON Schema into a single schema document by collecting all reference targets and rewriting the references to point to the bundled definitions. This ensures that the resulting schema is self-contained and can be used independently without relying on external documents.
- *
- * @param schema - The JSON Schema to bundle references for.
- * @returns A new JSON Schema with all references bundled and rewritten to point to the bundled definitions.
- */
-declare function bundleReferences(schema: JsonSchema): JsonSchema;
-/**
- * Creates a hash string for a given schema definition input.
- */
-declare function extractHash(variant: SchemaInputVariant, input: SchemaInput): string;
-/**
- * Converts a reflected Deepkit {@link Type} into a JSON Schema (draft-2020-12) representation.
- */
-declare function extractReflection(reflection: Type): JsonSchema | undefined;
-/**
- * Extracts a JSON Schema from Zod, Standard Schema, Valibot, untyped, or JSON Schema inputs.
- *
- * @param schema - The schema input to extract a JSON Schema from.
- * @returns The extracted JSON Schema, or `undefined` if the input is not a supported schema type.
- */
-declare function extractJsonSchema(schema: unknown): JsonSchema | undefined;
-/**
- * Resolves the concrete source variant for a schema source input.
- *
- * @param input - The schema source input to inspect.
- * @returns The resolved schema source variant.
- * @throws Will throw an error when the input cannot be mapped to a supported source variant.
- */
-declare function extractResolvedVariant(input: SchemaSourceInput): SchemaSourceVariant;
-/**
- * Determines the top-level input variant for schema extraction.
- *
- * @param input - The schema input to classify.
- * @returns The resolved schema input variant.
- */
-declare function extractVariant(input: SchemaInput): SchemaInputVariant;
-/**
- * Extracts and normalizes a JSON Schema from a concrete schema source input.
- *
- * @param input - The schema source input to extract from.
- * @param variant - Optional source variant override. When omitted, the variant is inferred from the input.
- * @returns A promise that resolves to a bundled JSON Schema.
- * @throws Will throw an error if no valid JSON Schema can be extracted from the input.
- */
-declare function extractSchema(input: SchemaSourceInput, variant?: SchemaInputVariant): Promise<JsonSchema>;
-/**
- * Builds source metadata for a schema input using a known source variant.
- *
- * @param variant - The schema source variant associated with the input.
- * @param input - The schema source input to wrap.
- * @returns The normalized schema source payload, including the source hash and variant.
- * @throws Will throw an error if the provided variant is unsupported.
- */
-declare function extractSource(variant: SchemaSourceVariant, input: SchemaSourceInput): SchemaSource;
-/**
- * Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a Deepkit Type object. If the input is a type definition reference (e.g. a file path with an export), it will be resolved and bundled using Rolldown to obtain the actual schema definition before extraction.
- *
- * @example
- * ```ts
- * // Resolve a schema definition from a file path
- * const schema1 = await extract(context, "./schemas.ts#MySchema");
- * // Resolve a schema definition from a JSON Schema object
- * const schema2 = await extract(context, schemaObject);
- * // Resolve a schema definition from a Zod schema
- * const schema3 = await extract(context, zodSchema);
- * // Resolve a schema definition from a reflected Deepkit Type object
- * const schema4 = await extract(context, reflectionType);
- * ```
- *
- * @see https://zod.dev/
- * @see https://valibot.dev/
- * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
- * @see https://json-schema.org/
- * @see https://ajv.js.org/json-type-definition.html
- * @see https://deepkit.io/en/documentation/runtime-types/reflection
- *
- * @param context - The context object providing access to the file system and cache path.
- * @param input - The schema definition input to extract, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a reflected Deepkit Type object. If the input is a string or a type definition reference, it will be resolved and bundled to obtain the actual schema definition before extraction.
- * @param options - Optional overrides for the Rolldown configuration used during extraction. This can include custom plugins, loaders, or other build options to control how the schema definition is resolved and bundled when the input is a type definition reference.
- * @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object. The function will attempt to extract a valid JSON Schema from the provided input, and if successful, it will return the schema. If the extraction process fails or if the input is not a valid schema definition, it will throw an error indicating the failure.
- */
-declare function extractSchemaWithSource(context: Context, input: SchemaInput, options?: BundleOptions): Promise<ExtractedSchema>;
-/**
- * Extracts a JSON Schema from a given schema definition input, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a Deepkit Type object. If the input is a type definition reference (e.g. a file path with an export), it will be resolved and bundled using Rolldown to obtain the actual schema definition before extraction.
- *
- * @example
- * ```ts
- * // Resolve a schema definition from a file path
- * const schema1 = await extract(context, "./schemas.ts#MySchema");
- * // Resolve a schema definition from a JSON Schema object
- * const schema2 = await extract(context, schemaObject);
- * // Resolve a schema definition from a Zod schema
- * const schema3 = await extract(context, zodSchema);
- * // Resolve a schema definition from a Valibot schema
- * const schema4 = await extract(context, valibotSchema);
- * // Resolve a schema definition from a reflected Deepkit Type object
- * const schema5 = await extract(context, reflectionType);
- * ```
- *
- * @see https://zod.dev/
- * @see https://valibot.dev/
- * @see https://standardschema.dev/json-schema#what-schema-libraries-support-this-spec
- * @see https://json-schema.org/
- * @see https://ajv.js.org/json-type-definition.html
- * @see https://deepkit.io/en/documentation/runtime-types/reflection
- * @see https://github.com/unjs/untyped
- * @see https://www.typescriptlang.org/docs/handbook/2/types-from-types.html
- *
- * @param context - The context object providing access to the file system and cache path.
- * @param input - The schema definition input to extract, which can be a Zod schema, a Valibot schema, any Standard JSON Schema type, a plain JSON Schema object, an untyped schema, or a reflected Deepkit Type object.
- * @param options - Optional overrides for the Rolldown configuration used during extraction.
- * @returns A promise that resolves to the extracted and normalized schema as a JSON Schema object.
- * @throws Will throw an error if the input is not a valid schema definition or if the extraction process fails to produce a valid schema.
- */
-declare function extract(context: Context, input: SchemaInput, options?: BundleOptions): Promise<Schema>;
-//#endregion
-//#region src/helpers.d.ts
-type GetPropertiesResult = JsonSchema & {
-  name: string;
-  required: boolean;
-  default?: unknown;
-};
-/**
- * Retrieves the JSON Schema from a Schema wrapper or returns the input if it's already a JSON Schema.
- *
- * @remarks
- * This function checks if the input is a Schema wrapper (an object with a `schema` property) and returns the `schema` if it is. If the input is already a JSON Schema, it returns it directly. This allows for flexibility in handling both raw JSON Schema objects and wrapped schemas without needing to check the type at every usage point.
- *
- * @param input - The input which can be either a Schema wrapper or a JSON Schema object.
- * @returns The JSON Schema object.
- * @throws Will throw a TypeError if the input is neither a valid Schema wrapper nor a valid JSON Schema object.
- */
-declare function getJsonSchema(input: Schema | JsonSchema): JsonSchema;
-/**
- * Retrieves the JSON Schema in Object form from a Schema wrapper or returns the input if it's already a JSON Schema.
- *
- * @remarks
- * This function checks if the input is a Schema wrapper (an object with a `schema` property) and returns the `schema` if it is. If the input is already a JSON Schema object, it returns it directly. This allows for flexibility in handling both raw JSON Schema objects and wrapped schemas without needing to check the type at every usage point.
- *
- * @param input - The input which can be either a Schema wrapper or a JSON Schema object.
- * @returns The JSON Schema object.
- * @throws Will throw a TypeError if the input is neither a valid Schema wrapper nor a valid JSON Schema object.
- */
-declare function getJsonSchemaObject(input: Schema | JsonSchema): JsonSchemaObject;
-/**
- * Extracts object properties from a JSON Schema object form.
- *
- * @remarks
- * This function returns an empty object if the schema is not an object form or if it has no properties.
- *
- * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
- * @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
- */
-declare function getProperties(obj: Schema | JsonSchemaObject): Record<string, JsonSchema & {
-  name: string;
-  required: boolean;
-  default?: unknown;
-}>;
-/**
- * Returns object properties as an array.
- *
- * @remarks
- * This is a convenience function that extracts properties using `getProperties` and returns them as an array.
- *
- * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
- * @returns An array of JSON Schema fragments representing the properties, each including metadata.
- */
-declare function getPropertiesList(obj: Schema | JsonSchemaObject): (JsonSchema & {
-  name: string;
-  required: boolean;
-  default?: unknown;
-})[];
-/**
- * Adds a property to a JSON Schema object form.
- *
- * @remarks
- * This function modifies the provided schema in place by adding a new property with the specified name and schema. It also updates the `required` array based on the `optional` flag of the property. If the property is marked as optional, it will be removed from the `required` array; otherwise, it will be added to it.
- *
- * @param obj - The JSON Schema object form or a Schema wrapper to which the property should be added.
- * @param name - The name of the property to add.
- * @param property - The JSON Schema fragment representing the property's schema, including metadata.
- * @throws Will throw an error if the provided schema is not an object form.
- */
-declare function addProperty(obj: Schema | JsonSchemaObject, name: string, property: JsonSchema): void;
-/**
- * Merges multiple JSON Schemas into one.
- *
- * @remarks
- * This function takes multiple JSON Schemas or Schema wrappers and merges them
- * into a single JSON Schema object. Later schemas in the argument list take
- * precedence over earlier ones for scalar conflicts.
- *
- * Structured keywords are merged recursively:
- * - Named child schemas (`properties`, `$defs`, etc.) are merged
- *   per-property via recursive calls to `merge`.
- * - Composition arrays (`allOf`, `anyOf`, `oneOf`) are concatenated.
- * - Single-schema keywords (`if`, `then`, `else`, `not`, `items`, etc.)
- *   are merged recursively when both sides define them.
- * - `required` arrays are unioned and deduplicated.
- *
- * @param schemas - An array of JSON Schemas or Schema wrappers to merge.
- * @returns A new JSON Schema that is the result of merging all input schemas.
- */
-declare function merge(...schemas: (JsonSchema | Schema)[]): JsonSchema;
-/**
- * Returns whether a JSON Schema fragment accepts `null`.
- *
- * @remarks
- * This is true if the schema has `nullable: true` or if its `type` includes `"null"`.
- *
- * @param schema - The JSON Schema fragment to check.
- * @returns `true` if the schema accepts `null`, otherwise `false`.
- */
-declare function isSchemaNullable(schema?: JsonSchema): boolean;
-/**
- * Returns whether an object property is optional (not listed in `required`).
- *
- * @remarks
- * In JSON Schema, object properties are optional by default unless they are listed in the `required` array of the parent schema. This function checks whether a given property name is not included in the `required` array of its parent schema, indicating that it is optional.
- *
- * @param parent - The parent JSON Schema object containing the property.
- * @param propertyName - The name of the property to check for optionality.
- * @returns `true` if the property is optional, otherwise `false`.
- */
-declare function isPropertyOptional(parent: JsonSchemaObject, propertyName: string): boolean;
-/**
- * Checks if a given file name has a valid schema input file extension.
- *
- * @param fileName - The file name to check for a valid schema input extension.
- * @returns `true` if the file name has a valid schema input extension, otherwise `false`.
- */
-declare function isValidSchemaInputFile(fileName: string): boolean;
-//#endregion
-//#region src/metadata.d.ts
-/**
- * Applies Powerlines schema metadata onto a JSON Schema fragment.
- *
- * @param schema - The JSON Schema fragment to apply metadata to.
- * @param metadata - The Powerlines schema metadata to apply.
- * @returns A new JSON Schema fragment with the metadata applied.
- */
-declare function applyJsonSchemaMetadata(schema: JsonSchema, metadata: JsonSchemaMetadataKeywords | undefined): JsonSchema;
-/**
- * Normalizes the JSON Schema `type` keyword to a string array.
- *
- * @remarks
- * This function ensures that the `type` keyword of a JSON Schema fragment is always represented as an array of strings, even if it was originally defined as a single string. This normalization simplifies type checking and processing of JSON Schemas by providing a consistent format for the `type` information.
- *
- * @param schema - The JSON Schema fragment to read types from.
- * @returns An array of JSON Schema primitive type names defined in the `type` keyword, or an empty array if no valid types are found.
- */
-declare function readSchemaTypes(schema?: JsonSchema): JsonSchemaPrimitiveType[];
-/**
- * Returns the primary non-null JSON Schema type name for a fragment.
- *
- * @param schema - The JSON Schema fragment to check.
- * @returns The primary non-null JSON Schema type name, or `undefined` if none is found.
- */
-declare function getPrimarySchemaType(schema?: JsonSchema): JsonSchemaPrimitiveType | undefined;
-//#endregion
-//#region src/persistence.d.ts
-/**
- * A helper function to get the cache directory path for storing schemas. This function takes a context object as input and returns the path to the cache directory where schemas are stored. The cache directory is constructed by joining the `cachePath` property from the context with a subdirectory named "schemas". This function is useful for centralizing the logic for determining where schema files should be cached, ensuring that all schema-related file operations use a consistent location for storing and retrieving cached schemas.
- *
- * @param context - The context object providing access to the cache path.
- * @returns The path to the cache directory for storing schemas, constructed by joining the context's `cachePath` with the "schemas" subdirectory.
- */
-declare function getCacheDirectory(context: Context): string;
-/**
- * A helper function to get the file path for a cached schema based on the provided context and schema input. This function first extracts the variant and hash from the input schema using the `extractVariant` and `extractHash` functions, respectively. It then constructs the file path to the cached schema JSON file by joining the cache directory path (obtained from the `getCacheDirectory` function) with a filename derived from the extracted hash. The resulting file path points to where the cached schema should be stored or retrieved from in the file system. This function is essential for ensuring that all operations related to caching schemas use a consistent method for determining the correct file path based on the schema's unique identifier (hash).
- *
- * @param context - The context object providing access to the cache path.
- * @param input - The input schema from which to extract the variant and hash for constructing the cache file path.
- * @returns The file path to the cached schema JSON file, constructed by joining the cache directory path with a filename derived from the extracted hash of the schema input.
- */
-declare function getCacheFilePath(context: Context, input: SchemaInput): string;
-/**
- * Writes a given schema to the file system using the provided context. This function first checks if the input is a valid schema using the `isSchema` type guard. If the input is not a valid schema, it throws an error indicating that the provided input is invalid. If the input is valid, it proceeds to write the schema to a JSON file in the cache directory specified by the context. The file is named using the hash of the schema to ensure uniqueness and easy retrieval in future operations. The schema is serialized to JSON format before being written to the file system. This function is asynchronous and returns a promise that resolves once the writing operation is complete.
- *
- * @param context - The context object providing access to the file system and cache path.
- * @param schema - The schema to be written to the file system, which must be a valid schema object containing a `variant`, `schema`, and `hash` property.
- * @throws Will throw an error if the provided input is not a valid schema.
- */
-declare function writeSchema(context: Context, schema: Schema): Promise<void>;
-/**
- * A helper function to read a schema from the file system using the provided context. This function first extracts the variant and hash from the input schema using the `extractVariant` and `extractHash` functions, respectively. It then constructs the file path to the cached schema JSON file based on the cache path provided in the context and the extracted hash. The function checks if the file exists in the cache; if it does not exist, it returns `undefined`. If the file exists, it reads the contents of the file, parses it as JSON, and returns the resulting object. This function is asynchronous and returns a promise that resolves to either the parsed schema object or `undefined` if the schema is not found in the cache.
- *
- * @param context - The context object providing access to the file system and cache path.
- * @param input - The input schema from which to extract the variant and hash for locating the cached schema file.
- * @returns A promise that resolves to the parsed schema object if found in the cache, or `undefined` if the schema does not exist in the cache.
- */
-declare function readSchemaSafe(context: Context, input: SchemaInput): Promise<Schema | undefined>;
-/**
- * Reads a schema from the file system using the provided context and input. This function first attempts to read the schema using the `readSchemaSafe` helper function, which returns `undefined` if the schema is not found in the cache. If the schema is not found, this function throws an error indicating that the schema with the specified variant and hash does not exist in the cache. The error message suggests that this may be due to a missing or corrupted cache file, or because the schema has not been written to the cache yet. It advises ensuring that the schema is properly written to the cache before attempting to read it. If the schema is successfully read from the cache, it is returned as a parsed object. This function is asynchronous and returns a promise that resolves to the parsed schema object if found, or throws an error if the schema is not found in the cache.
- *
- * @param context - The context object providing access to the file system and cache path.
- * @param input - The input schema from which to extract the variant and hash for locating the cached schema file.
- * @returns A promise that resolves to the parsed schema object if found in the cache, or throws an error if the schema does not exist in the cache.
- * @throws Will throw an error if the schema with the specified variant and hash does not exist in the cache.
- */
-declare function readSchema(context: Context, input: SchemaInput): Promise<Schema>;
-//#endregion
-//#region src/reflection.d.ts
-/**
- * Converts a Deepkit type reflection into a JSON Schema (draft-07) fragment.
- */
-declare function reflectionToJsonSchema(reflection: Type): JsonSchema | undefined;
-//#endregion
-//#region src/resolve.d.ts
-/**
- * Compiles a type definition to a module and returns the module.
- *
- * @param context - The context object containing the environment paths.
- * @param input - The type definition to compile. This can be either a string or a {@link FileReference} object.
- * @param overrides - Optional overrides for the ESBuild configuration.
- * @returns A promise that resolves to the compiled module.
- */
-declare function resolveModule<TResult, TContext extends UnresolvedContext = UnresolvedContext>(context: TContext, input: FileReferenceInput, overrides?: BundleOptions): Promise<TResult>;
-/**
- * Compiles a type definition to a module and returns the specified export from the module.
- *
- * @param context - The context object containing the environment paths.
- * @param input - The type definition to compile. This can be either a string or a {@link FileReference} object.
- * @param options - Optional overrides for the ESBuild configuration.
- * @returns A promise that resolves to the compiled module.
- */
-declare function resolve<TResult, TContext extends UnresolvedContext = UnresolvedContext>(context: TContext, input: FileReferenceInput, options?: BundleOptions): Promise<TResult>;
-/**
- * Resolves a type definition to a Deepkit Type reflection. This function compiles the provided type definition to a module, evaluates the module to get the specified export, and then reflects the export to get its Deepkit Type reflection.
- *
- * @param context - The context object containing the environment paths.
- * @param input - The type definition to compile. This can be either a string or a {@link FileReference} object.
- * @param options - Optional overrides for the ESBuild configuration.
- * @returns A promise that resolves to the Deepkit Type reflection.
- */
-declare function resolveReflection<TContext extends PluginContext = PluginContext>(context: TContext, input: FileReference, options?: BundleOptions): Promise<Type>;
-//#endregion
-//#region src/type-checks.d.ts
-/**
- * A helper type guard to check if a value is a JSON Schema primitive type.
- *
- * @param value - The value to check.
- * @returns True if the value is a JSON Schema primitive type, false otherwise.
- */
-declare function isJsonSchemaPrimitiveType(value: unknown): value is JsonSchemaPrimitiveType;
-/**
- * A helper type guard to check if a value is a JSON Schema type.
- *
- * @param value - The value to check.
- * @returns True if the value is a JSON Schema type, false otherwise.
- */
-declare function isJsonSchemaType(value: unknown): value is JsonSchemaType;
-/**
- * Type guard for shared JSON Schema keyword groups.
- *
- * @param input - The value to check.
- * @returns True if the input is a JSON Schema keyword group, false otherwise.
- */
-declare function isJsonSchemaKeywords(input: unknown): input is JsonSchemaKeywords;
-/**
- * Type guard for generic JSON Schema objects with optional `$ref`.
- *
- * @param input - The value to check.
- * @returns True if the input is a generic JSON Schema object, false otherwise.
- */
-declare function isJsonSchemaAny(input: unknown): input is JsonSchemaAny;
-/**
- * Type guard for JSON Schema array types.
- *
- * @param input - The value to check.
- * @returns True if the input is a JSON Schema array schema, false otherwise.
- */
-declare function isJsonSchemaArray(input: unknown): input is JsonSchemaArray;
-/**
- * Type guard for bigint-backed integer schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a bigint-backed integer schema, false otherwise.
- */
-declare function isJsonSchemaBigint(input: unknown): input is JsonSchemaBigint;
-/**
- * Type guard for boolean schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a boolean schema, false otherwise.
- */
-declare function isJsonSchemaBoolean(input: unknown): input is JsonSchemaBoolean;
-/**
- * Type guard for date/time schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a date or time schema, false otherwise.
- */
-declare function isJsonSchemaDate(input: unknown): input is JsonSchemaDate;
-/**
- * Type guard for enum-constrained schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is an enum-constrained schema, false otherwise.
- */
-declare function isJsonSchemaEnum(input: unknown): input is JsonSchemaEnum;
-/**
- * Type guard for `allOf` composition schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is an `allOf` schema, false otherwise.
- */
-declare function isJsonSchemaAllOf(input: unknown): input is JsonSchemaAllOf;
-/**
- * Type guard for literal-value schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a literal-value schema, false otherwise.
- */
-declare function isJsonSchemaLiteral(input: unknown): input is JsonSchemaLiteral;
-/**
- * Type guard for map tuple-array schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a map tuple-array schema, false otherwise.
- */
-declare function isJsonSchemaMap(input: unknown): input is JsonSchemaMap;
-/**
- * Type guard for native enum schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a native enum schema, false otherwise.
- */
-declare function isJsonSchemaNativeEnum(input: unknown): input is JsonSchemaNativeEnum;
-/**
- * Type guard for impossible/never schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a never schema, false otherwise.
- */
-declare function isJsonSchemaNever(input: unknown): input is JsonSchemaNever;
-/**
- * Type guard for `null` schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a null schema, false otherwise.
- */
-declare function isJsonSchemaNull(input: unknown): input is JsonSchemaNull;
-/**
- * Type guard for nullable schema unions.
- *
- * @param input - The value to check.
- * @returns True if the input is a nullable schema union, false otherwise.
- */
-declare function isJsonSchemaNullable(input: unknown): input is JsonSchemaNullable;
-/**
- * Type guard for numeric schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a numeric schema, false otherwise.
- */
-declare function isJsonSchemaNumber(input: unknown): input is JsonSchemaNumber;
-/**
- * Type guard for integer schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is an integer schema, false otherwise.
- */
-declare function isJsonSchemaInteger(input: unknown): input is JsonSchemaInteger;
-/**
- * Type guard for decimal schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a decimal schema, false otherwise.
- */
-declare function isJsonSchemaDecimal(input: unknown): input is JsonSchemaDecimal;
-/**
- * Type guard for object schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is an object schema, false otherwise.
- */
-declare function isJsonSchemaObject(input: unknown): input is JsonSchemaObject;
-/**
- * Type guard for string schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a string schema, false otherwise.
- */
-declare function isJsonSchemaString(input: unknown): input is JsonSchemaString;
-/**
- * Type guard for set-like array schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a set-like array schema, false otherwise.
- */
-declare function isJsonSchemaSet(input: unknown): input is JsonSchemaSet;
-/**
- * Type guard for record schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a record schema, false otherwise.
- */
-declare function isJsonSchemaRecord(input: unknown): input is JsonSchemaRecord;
-/**
- * Type guard for tuple schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a tuple schema, false otherwise.
- */
-declare function isJsonSchemaTuple(input: unknown): input is JsonSchemaTuple;
-/**
- * Type guard for undefined-representing schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is an undefined-representing schema, false otherwise.
- */
-declare function isJsonSchemaUndefined(input: unknown): input is JsonSchemaUndefined;
-/**
- * Type guard for primitive-union schema variants.
- *
- * @param input - The value to check.
- * @returns True if the input is a primitive-union schema variant, false otherwise.
- */
-declare function isJsonSchemaPrimitiveUnion(input: unknown): input is JsonSchemaPrimitiveUnion;
-/**
- * Type guard for union schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a union schema, false otherwise.
- */
-declare function isJsonSchemaUnion(input: unknown): input is JsonSchemaUnion;
-/**
- * Type guard for permissive unknown schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a permissive unknown schema, false otherwise.
- */
-declare function isJsonSchemaUnknown(input: unknown): input is JsonSchemaUnknown;
-/**
- * Type guard for `anyOf` composition schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is an `anyOf` schema, false otherwise.
- */
-declare function isJsonSchemaAnyOf(input: unknown): input is JsonSchemaAnyOf;
-/**
- * Type guard for reference schemas.
- *
- * @param input - The value to check.
- * @returns True if the input is a reference schema, false otherwise.
- */
-declare function isJsonSchemaRef(input: unknown): input is JsonSchemaRef;
-/**
- * Type guard for Standard Schema V1 objects.
- *
- * @param input - The value to check.
- * @returns True if the input is a Standard Schema V1 object, false otherwise.
- */
-declare function isStandardSchema(input: unknown): input is StandardSchemaV1;
-/**
- * Type guard for Valibot BaseSchema objects.
- *
- * @param input - The value to check.
- * @returns True if the input is a Valibot BaseSchema, false otherwise.
- */
-declare function isValibotSchema(input: unknown): input is BaseSchema<any, any, any>;
-/**
- * Type guard for JSON Schema types.
- *
- * @remarks
- * This function checks if the input is a JSON Schema type, which is defined as having a `type` property or a `$ref` property. This is used to determine if a given input conforms to the structure of a JSON Schema definition that includes type information.
- *
- * @param input - The value to check.
- * @returns True if the input is a JSON Schema type, false otherwise.
- */
-declare function isJsonSchema(input: unknown): input is JsonSchema;
-/**
- * Type guard for JSON Schemas that only accept `null`.
- *
- * @remarks
- * This function checks if the input is a JSON Schema that exclusively accepts the `null` type. It verifies that the input is a valid JSON Schema and that its `type` property is set to "null". This is useful for identifying schemas that are specifically designed to allow only `null` values.
- *
- * @param input - The value to check.
- * @returns True if the input is a JSON Schema that only accepts `null`, false otherwise.
- */
-declare function isNullOnlyJsonSchema(input: unknown): input is JsonSchemaNull;
-/**
- * Type guard for untyped schema objects.
- *
- * @remarks
- * This function checks if the input is an untyped schema object, which is defined as having certain properties that are commonly found in untyped schema definitions. This includes properties such as `id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., strings for certain properties, arrays for others). This type guard is used to determine if a given input can be treated as an untyped schema object within the context of the Powerlines schema system.
- *
- * @param input - The value to check.
- * @returns True if the input is an untyped schema object, false otherwise.
- */
-declare function isUntypedSchema(input: unknown): input is Schema$1;
-/**
- * Strict type guard for untyped schema objects.
- *
- * @remarks
- * This guard narrows values to the Untyped schema model while explicitly
- * rejecting values that are also valid JSON Schema instances.
- *
- * @param input - The value to check.
- * @returns True if the input is an untyped schema and not a JSON Schema.
- */
-declare function isUntypedSchemaStrict(input: unknown): input is Schema$1;
-/**
- * Type guard for untyped input objects.
- *
- * @remarks
- * This function checks if the input is an untyped input object, which is defined as having certain properties that are commonly found in untyped input definitions. This includes properties such as `$schema` and `$resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., objects for `$schema`, functions for `$resolve`). This type guard is used to determine if a given input can be treated as an untyped input object within the context of the Powerlines schema system.
- *
- * @param input - The value to check.
- * @returns True if the input is an untyped input object, false otherwise.
- */
-declare function isUntypedInput(input: unknown): input is InputObject;
-/**
- * Strict type guard for untyped input objects.
- *
- * @remarks
- * This guard narrows values to the Untyped input-object model while
- * explicitly rejecting values that are valid JSON Schema objects.
- *
- * @param input - The value to check.
- * @returns True if the input is an untyped input object and not JSON Schema.
- */
-declare function isUntypedInputStrict(input: unknown): input is InputObject;
-/**
- * Type guard for Powerlines Schema objects.
- *
- * @param input - The value to check.
- * @returns True if the input is a Powerlines Schema object, false otherwise.
- */
-declare function isSchema(input: unknown): input is Schema;
-/**
- * Type guard for extracted schema objects that include source information.
- *
- * @param input - The value to check.
- * @returns True if the input is a SchemaWithSource object, false otherwise.
- */
-declare function isSchemaWithSource(input: unknown): input is ExtractedSchema;
-/**
- * Type guard for Powerlines Schemas that are in Object form.
- *
- * @param input - The value to check.
- * @returns True if the input is a Powerlines Schema object in Object form, false otherwise.
- */
-declare function isSchemaObject(input: unknown): input is Schema<JsonSchemaObject>;
-//#endregion
 //#region src/index.d.ts
 declare module "zod" {
   interface GlobalMeta {