export { C as CompileOptions, a as CompileStats, b as CompiledFlatSchema, c as CompiledPredicate, d as CompiledSchema, e as CompiledTreeSchema, F as FlatValidationResult, S as StrictIssue, T as TreeValidationResult, V as ValidationResult, f as compileSchema, s as schemaUsesUnevaluated } from './compiler-Cudx5OYj.cjs';
import { v as Vocabulary, D as Dialect, K as KeywordDefinition } from './runtime-BXoST4J7.cjs';
export { x as CompileAndCallOptions, y as CompileRuntime, b as CompiledRegex, c as CustomKeywordFailure, C as CustomKeywordValidator, z as DialectRules, E as ErrorKind, f as KeywordCompileContext, R as RefResolver, a as RegexCompiler, A as ResolveOptions, B as ResolvedGraph, F as ValidateSubschemaOptions, G as Validator, H as createCustomKeywordDefinition, I as createRefResolver, J as customKeywordVocabulary, L as resolve } from './runtime-BXoST4J7.cjs';
export { c as SubschemaVisitor, w as walkSubschemas } from './subschema-positions-DVmZKEu5.cjs';
import './errors-BahYESV_.cjs';
import './types-Dzi0PpYX.cjs';

declare const CORE_VOCAB = "https://json-schema.org/draft/2020-12/vocab/core";
declare const CORE_VALIDATION_VOCAB = "https://json-schema.org/draft/2020-12/vocab/validation";
declare const APPLICATOR_VOCAB = "https://json-schema.org/draft/2020-12/vocab/applicator";
declare const UNEVALUATED_VOCAB = "https://json-schema.org/draft/2020-12/vocab/unevaluated";
declare const FORMAT_VOCAB = "https://json-schema.org/draft/2020-12/vocab/format-annotation";
declare const FORMAT_ASSERTION_VOCAB = "https://json-schema.org/draft/2020-12/vocab/format-assertion";
declare const META_DATA_VOCAB = "https://json-schema.org/draft/2020-12/vocab/meta-data";
declare const CONTENT_VOCAB = "https://json-schema.org/draft/2020-12/vocab/content";
declare const OAS30_VOCAB = "https://spec.openapis.org/oas/3.0/vocab/schema";
declare const OPENAPI_META_DATA_VOCAB = "https://spec.openapis.org/oas/vocab/meta-data";

/**
 * The JSON Schema 2020-12 core vocabulary: `$ref`, `$dynamicRef`, `$id`,
 * `$defs`, anchors, etc. No runtime behavior except `$ref` / `$dynamicRef`.
 *
 * @public
 */
declare const coreVocabulary: Vocabulary;
/**
 * The built-in validation vocabulary: `type`, `enum`, `const`, numeric
 * bounds, string bounds, array bounds, and `required`. Applicator keywords
 * live in a separate vocabulary.
 *
 * @public
 */
declare const validationVocabulary: Vocabulary;
/**
 * The built-in applicator vocabulary: composition keywords that recurse into
 * subschemas.
 *
 * @public
 */
declare const applicatorVocabulary: Vocabulary;
/**
 * The built-in unevaluated vocabulary: `unevaluatedProperties` /
 * `unevaluatedItems`.
 *
 * @public
 */
declare const unevaluatedVocabulary: Vocabulary;
/**
 * The built-in format-annotation vocabulary. Non-assertive per the spec
 * default; use {@link formatAssertionVocabulary} to make `format`
 * actually reject data.
 *
 * @public
 */
declare const formatVocabulary: Vocabulary;
/**
 * Opt-in format-assertion vocabulary. Place BEFORE {@link formatVocabulary}
 * in the vocabularies list so its assertive `format` keyword wins keyword
 * dispatch.
 *
 * @public
 */
declare const formatAssertionVocabulary: Vocabulary;
/**
 * The JSON Schema 2020-12 Meta-Data vocabulary. Pure annotations: these
 * keywords carry human- and tool-facing metadata and never reject data.
 * Registering them explicitly gives the compiler's inliner a single,
 * dialect-scoped source of truth for "which keys are safe to ignore".
 *
 * @public
 */
declare const metaDataVocabulary: Vocabulary;
/**
 * OpenAPI-specific annotations layered on top of
 * {@link metaDataVocabulary}. Carries the singular `example`
 * (deprecated in 3.1 but widely used), `xml` (XML serialisation hints
 * on Schema Objects), and `externalDocs` (pointer to external docs).
 * All annotation-only.
 *
 * @public
 */
declare const openapiMetaDataVocabulary: Vocabulary;
/**
 * The JSON Schema 2020-12 Content vocabulary: `contentEncoding`,
 * `contentMediaType`, `contentSchema`. The spec marks the content
 * vocabulary as not required to validate; oav treats all three as
 * pure annotations so schemas using them lint clean in strict mode.
 *
 * @public
 */
declare const contentVocabulary: Vocabulary;
/**
 * The three default vocabularies (validation + applicator +
 * format-annotation) in the order the compiler expects. Consumers
 * normally pick a full {@link Dialect} instead; see
 * {@link jsonSchemaDialect}, {@link openapi31Dialect}, and
 * {@link oas30Dialect}.
 *
 * @public
 */
declare const defaultVocabularies: readonly Vocabulary[];
/**
 * The OpenAPI 3.0 vocabulary overrides.
 *
 * Placed AHEAD of the standard validation + applicator vocabularies
 * in a 3.0 compile so its flavours of `type`, `maximum`, `minimum`,
 * and the modifier keywords (`nullable`, `exclusiveMaximum`,
 * `exclusiveMinimum`) win keyword dispatch over the 2020-12 variants.
 *
 * @public
 */
declare const oas30Vocabulary: Vocabulary;
/**
 * JSON Schema 2020-12 dialect. `format` is treated as an annotation
 * (non-assertive) per the spec default.
 *
 * @public
 */
declare const jsonSchemaDialect: Dialect;
/**
 * OpenAPI 3.1 / 3.2 dialect. Uses the 2020-12 vocabulary stack with
 * `format` promoted to assertion (OpenAPI semantics).
 *
 * @public
 */
declare const openapi31Dialect: Dialect;
/**
 * OpenAPI 3.0 dialect. Uses the OAS 3.0 keyword flavours (string-only
 * `type` with sibling `nullable`, boolean `exclusiveMaximum` /
 * `exclusiveMinimum`) and the `$ref`-suppresses-siblings rule.
 * `unevaluatedProperties` / `unevaluatedItems` are not present in 3.0
 * so the unevaluated vocabulary is omitted.
 *
 * @public
 */
declare const oas30Dialect: Dialect;

/**
 * The JSON Schema `maxItems` keyword. Array data must have at most N items.
 *
 * @public
 */
declare const maxItemsKeyword: KeywordDefinition;
/**
 * The JSON Schema `minItems` keyword. Array data must have at least N items.
 *
 * @public
 */
declare const minItemsKeyword: KeywordDefinition;
/**
 * The JSON Schema `uniqueItems` keyword. When set to `true`, every array
 * item must be pairwise not-deep-equal.
 *
 * @public
 */
declare const uniqueItemsKeyword: KeywordDefinition;

/**
 * The `allOf` keyword. Every subschema must validate. Children of the
 * produced error are the failing conjuncts.
 *
 * @public
 */
declare const allOfKeyword: KeywordDefinition;
/**
 * The `anyOf` keyword. At least one subschema must validate. Children of the
 * produced error (emitted only when NONE match) are the branch errors.
 *
 * @public
 */
declare const anyOfKeyword: KeywordDefinition;
/**
 * The `oneOf` keyword. Exactly one subschema must validate. Children of the
 * produced error are the per-branch failures.
 *
 * @public
 */
declare const oneOfKeyword: KeywordDefinition;
/**
 * The `not` keyword. Data must NOT validate against the subschema.
 *
 * @public
 */
declare const notKeyword: KeywordDefinition;
/**
 * The `if` / `then` / `else` triplet. Handled as one keyword because the
 * three are semantically coupled: `if` branches into `then` (on match) or
 * `else` (on mismatch), and `if` itself emits no errors.
 *
 * @public
 */
declare const ifThenElseKeyword: KeywordDefinition;
/**
 * The `dependentSchemas` keyword. When a given property is present, the
 * whole object is validated against the dependent subschema.
 *
 * @public
 */
declare const dependentSchemasKeyword: KeywordDefinition;
/**
 * The draft-07-compat `dependencies` keyword. Dispatches per entry:
 * array values get `dependentRequired` semantics; object/boolean
 * values get `dependentSchemas` semantics. Kept as a distinct
 * keyword so schemas authored against older drafts but served under
 * a 2020-12 dialect still validate.
 *
 * @public
 */
declare const dependenciesKeyword: KeywordDefinition;
/**
 * The `dependentRequired` keyword. When a given property is present, each
 * listed companion property must also be present.
 *
 * @public
 */
declare const dependentRequiredKeyword: KeywordDefinition;

/**
 * The JSON Schema 2020-12 `enum` keyword. Data must be deep-equal to one of
 * the listed values.
 *
 * @public
 */
declare const enumKeyword: KeywordDefinition;
/**
 * The JSON Schema 2020-12 `const` keyword. Data must be deep-equal to the
 * provided constant.
 *
 * @public
 */
declare const constKeyword: KeywordDefinition;

/**
 * The `prefixItems` keyword. Validates the first N items of an array against
 * a tuple of subschemas.
 *
 * @public
 */
declare const prefixItemsKeyword: KeywordDefinition;
/**
 * The `items` keyword. Validates every array item AFTER the prefixItems
 * window (or every item if no prefixItems).
 *
 * @public
 */
declare const itemsKeyword: KeywordDefinition;
/**
 * The `contains` keyword. The array must have at least `minContains`
 * (default 1) and at most `maxContains` items matching the subschema.
 *
 * Dispatches for `minContains` and `maxContains` are suppressed; this
 * keyword handles them.
 *
 * @public
 */
declare const containsKeyword: KeywordDefinition;

/**
 * The JSON Schema 2020-12 Meta-Data vocabulary. These keywords are
 * annotation-only: they carry human- or tool-facing metadata and emit
 * no runtime validation code. Registering them as first-class keyword
 * definitions (rather than tolerating them as unknown keys) gives the
 * compiler a single source of truth for the set, which the subschema
 * inliner and any future introspection consult via the shared
 * `annotation: true` flag.
 */

/**
 * `title`: a short human-readable label for the schema. Annotation-
 * only; emits no validation code. Bundled into
 * {@link metaDataVocabulary} and reachable alongside it from
 * `oav/schema`.
 *
 * @public
 */
declare const titleKeyword: KeywordDefinition;
/**
 * `description`: a longer human-readable explanation of the schema.
 * Annotation-only; emits no validation code. Pair with
 * {@link titleKeyword} for tooling that displays a label plus details.
 *
 * @public
 */
declare const descriptionKeyword: KeywordDefinition;
/**
 * `default`: a suggested default value for the schema. Preserved as
 * metadata only; oav never injects defaults into request bodies or
 * response bodies (see the `useDefaults` discussion in
 * [`docs/comparison.md`](../../../docs/comparison.md) if you need that behavior).
 *
 * @public
 */
declare const defaultKeyword: KeywordDefinition;
/**
 * `deprecated`: marks a schema (most often a single property) as
 * deprecated. Annotation-only: deprecated values are not rejected at
 * runtime. Tooling and generated clients use it to surface warnings.
 *
 * @public
 */
declare const deprecatedKeyword: KeywordDefinition;
/**
 * `readOnly`: flags a property the client MUST NOT send on request
 * bodies. Annotation-only inside the schema compiler; the validator's
 * request-side body transform consults it and rewrites such properties
 * to `false` on request-direction schemas. Companion to
 * {@link writeOnlyKeyword}.
 *
 * @public
 */
declare const readOnlyKeyword: KeywordDefinition;
/**
 * `writeOnly`: flags a property the server MUST NOT send on response
 * bodies. Annotation-only inside the schema compiler; the validator's
 * response-side body transform consults it and rewrites such properties
 * to `false` on response-direction schemas. Companion to
 * {@link readOnlyKeyword}.
 *
 * @public
 */
declare const writeOnlyKeyword: KeywordDefinition;
/**
 * `examples`: an array of example values the schema author supplies
 * for documentation and tooling. Annotation-only; emits no validation
 * code. Supersedes OpenAPI 3.0's singular {@link exampleKeyword}.
 *
 * @public
 */
declare const examplesKeyword: KeywordDefinition;
/**
 * OpenAPI-specific annotation: `example` (singular). Deprecated in
 * favor of `examples` per OpenAPI 3.1, still widely used in 3.0 specs.
 *
 * @public
 */
declare const exampleKeyword: KeywordDefinition;
/**
 * OpenAPI Schema Object's `xml` annotation. Describes how a property
 * serialises to XML (element name, namespace, attribute placement).
 * Annotation-only for JSON validation; oav doesn't emit XML.
 * Spec-defined on the OpenAPI Schema Object across 3.0 / 3.1 / 3.2.
 *
 * @public
 */
declare const xmlKeyword: KeywordDefinition;
/**
 * OpenAPI Schema Object's `externalDocs` annotation: pointer to
 * additional external documentation for this schema. Annotation-only.
 * Spec-defined fixed field on the Schema Object across 3.0 / 3.1 / 3.2.
 *
 * @public
 */
declare const externalDocsKeyword: KeywordDefinition;
/**
 * JSON Schema 2020-12 `contentEncoding`: declares the encoding (e.g.
 * `base64`) used for a string value. The spec marks the content
 * vocabulary as not required to validate; oav treats it as
 * annotation-only.
 *
 * @public
 */
declare const contentEncodingKeyword: KeywordDefinition;
/**
 * JSON Schema 2020-12 `contentMediaType`: declares the media type
 * (e.g. `application/jwt`) of a string value's content. Annotation-only
 * companion to {@link contentEncodingKeyword}.
 *
 * @public
 */
declare const contentMediaTypeKeyword: KeywordDefinition;
/**
 * JSON Schema 2020-12 `contentSchema`: schema describing the structure
 * of decoded content (after applying `contentEncoding` and parsing
 * `contentMediaType`). Annotation-only; oav doesn't decode + re-validate.
 *
 * @public
 */
declare const contentSchemaKeyword: KeywordDefinition;

/**
 * The JSON Schema `multipleOf` keyword. Data must be divisible by the schema
 * value (without floating-point remainder).
 *
 * The check compares `data / divisor` against its nearest integer with a
 * relative epsilon so valid multiples aren't rejected when the division
 * produces a non-terminating binary fraction. IEEE-754 rounding error
 * grows roughly with magnitude, so a flat tolerance is wrong at both
 * ends: a value like `143.48 / 0.01` drifts by about `1.82e-12`, while
 * values near `1` stay within `1e-14`. Scaling by `Number.EPSILON *
 * max(1, |q|, |divisor|)` gives each multiple of `divisor` the same
 * proportional slack without letting true non-multiples sneak through.
 *
 * @public
 */
declare const multipleOfKeyword: KeywordDefinition;
/**
 * The JSON Schema `maximum` keyword. Data must be <= the schema value.
 *
 * @public
 */
declare const maximumKeyword: KeywordDefinition;
/**
 * The JSON Schema `exclusiveMaximum` keyword. Data must be < the schema value.
 *
 * @public
 */
declare const exclusiveMaximumKeyword: KeywordDefinition;
/**
 * The JSON Schema `minimum` keyword. Data must be >= the schema value.
 *
 * @public
 */
declare const minimumKeyword: KeywordDefinition;
/**
 * The JSON Schema `exclusiveMinimum` keyword. Data must be > the schema value.
 *
 * @public
 */
declare const exclusiveMinimumKeyword: KeywordDefinition;

/**
 * OpenAPI 3.0.x Schema Object keywords.
 *
 * 3.0 uses a constrained JSON Schema Wright-00 dialect with three
 * deviations from the 2020-12 dialect used by 3.1 / 3.2:
 *
 * 1. `type` is a single string (never an array), and nullability is
 *    expressed via a sibling `nullable: true` instead of
 *    `type: ["…", "null"]`.
 * 2. `exclusiveMaximum` / `exclusiveMinimum` are **booleans**: they
 *    modify the sibling `maximum` / `minimum` rather than standing
 *    alone as numeric bounds.
 * 3. `$ref`, when present, causes every sibling keyword to be
 *    ignored. The containing schema is _only_ the reference.
 *
 * Each of these gets its own keyword implementation in this file;
 * everything else (string/array/object bounds, required, enum, the
 * applicators we support in 3.0, etc.) reuses the 2020-12 vocabulary
 * as-is.
 *
 * @packageDocumentation
 */

/**
 * The `type` keyword in OAS 3.0: MUST be a single string. If the
 * sibling `nullable: true` is also set, the predicate additionally
 * admits `null`.
 *
 * @public
 */
declare const oas30TypeKeyword: KeywordDefinition;
/**
 * The `nullable` keyword is a metadata flag that the OAS 3.0 `type`
 * keyword consults on its sibling lookup. This entry exists so the
 * dispatcher doesn't flag it as an unknown keyword; it emits no
 * validation code.
 *
 * @public
 */
declare const oas30NullableKeyword: KeywordDefinition;
/**
 * OAS 3.0's `maximum`. Looks at the sibling `exclusiveMaximum`
 * boolean to decide whether the check is `<=` (default) or `<`
 * (exclusive).
 *
 * @public
 */
declare const oas30MaximumKeyword: KeywordDefinition;
/**
 * OAS 3.0's `minimum`. Looks at the sibling `exclusiveMinimum`
 * boolean to decide whether the check is `>=` (default) or `>`.
 *
 * @public
 */
declare const oas30MinimumKeyword: KeywordDefinition;
/**
 * OAS 3.0's `exclusiveMaximum` is a metadata boolean consumed by
 * {@link oas30MaximumKeyword}. No validation code on its own.
 *
 * @public
 */
declare const oas30ExclusiveMaximumKeyword: KeywordDefinition;
/**
 * OAS 3.0's `exclusiveMinimum` is a metadata boolean consumed by
 * {@link oas30MinimumKeyword}.
 *
 * @public
 */
declare const oas30ExclusiveMinimumKeyword: KeywordDefinition;

/**
 * The JSON Schema `maxProperties` keyword.
 *
 * @public
 */
declare const maxPropertiesKeyword: KeywordDefinition;
/**
 * The JSON Schema `minProperties` keyword.
 *
 * @public
 */
declare const minPropertiesKeyword: KeywordDefinition;
/**
 * The JSON Schema `required` keyword. Object data must declare every name
 * in the array. Produces one error per missing property so consumers see a
 * complete report.
 *
 * @public
 */
declare const requiredKeyword: KeywordDefinition;

/**
 * The `properties` keyword. For each named property present in the data,
 * validate its value against the corresponding subschema.
 *
 * @public
 */
declare const propertiesKeyword: KeywordDefinition;
/**
 * The `patternProperties` keyword. Keys matching each regex are validated
 * against the corresponding subschema. A single key may match multiple
 * patterns and be validated against each.
 *
 * @public
 */
declare const patternPropertiesKeyword: KeywordDefinition;
/**
 * The `additionalProperties` keyword. Validates every property NOT covered
 * by `properties` or `patternProperties` against the given subschema.
 *
 * @public
 */
declare const additionalPropertiesKeyword: KeywordDefinition;
/**
 * The `propertyNames` keyword. Each key name is validated as a string
 * against the given subschema.
 *
 * @public
 */
declare const propertyNamesKeyword: KeywordDefinition;

/**
 * The JSON Schema 2020-12 `$ref` keyword. Resolves the reference to another
 * schema and delegates validation to its compiled function.
 *
 * Circular references are handled by the compiler's schema-identity cache:
 * the function name is reserved before the body is generated, so a recursive
 * `$ref` back to the enclosing schema compiles to a normal recursive call.
 *
 * @public
 */
declare const refKeyword: KeywordDefinition;
/**
 * The JSON Schema 2020-12 `$dynamicRef` keyword. For schemas that do not use
 * `$dynamicAnchor` extension points this behaves exactly like `$ref`: the
 * anchor is resolved statically against the schema tree.
 *
 * @public
 */
declare const dynamicRefKeyword: KeywordDefinition;
/**
 * Declarative `$dynamicAnchor` keyword. Collected during resolution; no
 * runtime code is emitted.
 *
 * @public
 */
declare const dynamicAnchorKeyword: KeywordDefinition;
/**
 * Declarative `$anchor` keyword. Collected during resolution; no runtime
 * code is emitted.
 *
 * @public
 */
declare const anchorKeyword: KeywordDefinition;
/**
 * Declarative `$id` keyword. Collected during resolution; no runtime code
 * is emitted.
 *
 * @public
 */
declare const idKeyword: KeywordDefinition;
/**
 * Declarative `$defs` keyword. Its value is a record of subschemas
 * reachable via `$ref`; no runtime code is emitted.
 *
 * @public
 */
declare const defsKeyword: KeywordDefinition;
/**
 * Declarative `$schema` keyword. No runtime behavior.
 *
 * @public
 */
declare const schemaDialectKeyword: KeywordDefinition;
/**
 * Declarative `$comment` keyword. No runtime behavior.
 *
 * @public
 */
declare const commentKeyword: KeywordDefinition;

/**
 * The JSON Schema `maxLength` keyword. String data must have at most N
 * (UTF-16 code-unit-safe) characters.
 *
 * @public
 */
declare const maxLengthKeyword: KeywordDefinition;
/**
 * The JSON Schema `minLength` keyword. String data must have at least N
 * characters.
 *
 * @public
 */
declare const minLengthKeyword: KeywordDefinition;
/**
 * The JSON Schema `pattern` keyword. String data must match the ECMA-262
 * regex given as the schema value.
 *
 * @public
 */
declare const patternKeyword: KeywordDefinition;
/**
 * The JSON Schema 2020-12 `format` keyword, annotation-only mode. Matches
 * the spec default: `format` is a structural hint, not an assertion. Use
 * {@link formatAssertionKeyword} (or the OpenAPI validator) to actually
 * reject malformed strings.
 *
 * @public
 */
declare const formatKeyword: KeywordDefinition;
/**
 * The JSON Schema 2020-12 `format` keyword, assertion mode. When a
 * validator is registered for the named format, the string must pass it.
 * Callers activate this by including {@link formatAssertionVocabulary}
 * ahead of {@link formatVocabulary}.
 *
 * @public
 */
declare const formatAssertionKeyword: KeywordDefinition;

/**
 * The JSON Schema 2020-12 `type` keyword. Accepts a single type name or an
 * array of names; a value validates if its JSON type matches at least one.
 *
 * @public
 */
declare const typeKeyword: KeywordDefinition;

/**
 * The OpenAPI 3.1 `discriminator` object. When present alongside `oneOf`,
 * the validator reads the named property, looks it up in `mapping`, and
 * validates the data against ONLY the selected branch, producing a
 * single-branch failure tree rather than N branches.
 *
 * @remarks
 * When `discriminator` is present the normal `oneOf` pathway is suppressed
 * via the `implements` field.
 *
 * @public
 */
declare const discriminatorKeyword: KeywordDefinition;

/**
 * The `unevaluatedProperties` keyword. Validates every property NOT already
 * evaluated by sibling keywords (`properties`, `patternProperties`,
 * `additionalProperties`) or by any composition keyword (`allOf`,
 * `anyOf`, `oneOf`, `$ref`, `if`/`then`/`else`, `dependentSchemas`) in the
 * enclosing scope, against the given subschema. Annotations from failing
 * subschemas are discarded per the 2020-12 spec.
 *
 * @public
 */
declare const unevaluatedPropertiesKeyword: KeywordDefinition;
/**
 * The `unevaluatedItems` keyword. Validates every array index NOT already
 * evaluated by sibling keywords (`prefixItems`, `items`, `contains`) or by
 * any composition keyword in the enclosing scope, against the given
 * subschema.
 *
 * @public
 */
declare const unevaluatedItemsKeyword: KeywordDefinition;

/**
 * Read-only introspection over the built-in keyword set: enumerate the
 * keywords a dialect dispatches, and read their classification flags
 * (`applicator` / `annotation` / `evaluates` / `implements`) off the
 * `@public` {@link KeywordDefinition}. For walking a schema's subschema
 * positions see {@link walkSubschemas}; for the `unevaluated*` gate see
 * `schemaUsesUnevaluated` (both also `@public`).
 *
 * This is the consumer-facing half of the keyword surface (reading
 * keyword metadata), distinct from the keyword-authoring surface
 * (defining keywords). Tooling that reasons about keywords (a linter, a
 * coverage check, the streaming validator's classifier) reads here; it
 * never needs the codegen internals.
 *
 * @packageDocumentation
 */

/**
 * The built-in keyword set a dialect dispatches, as a flat
 * `keyword name -> {@link KeywordDefinition}` map. Each definition
 * carries its classification flags (`applicator`, `annotation`,
 * `evaluates`, `implements`, `partial`), so a consumer can bucket every
 * keyword without re-deriving the vocabulary stack.
 *
 * The map mirrors the compiler's dispatch precedence: keywords are
 * flattened across the dialect's vocabularies in order, first-wins on a
 * repeated name. For {@link oas30Dialect} that means `get("type")`
 * returns the 3.0 `type` flavour (string-only, sibling `nullable`), not
 * the 2020-12 one, because `oas30Vocabulary` sits ahead of the standard
 * validation vocabulary in that dialect's stack.
 *
 * @param dialect - The dialect to enumerate. Defaults to
 *   {@link jsonSchemaDialect} (JSON Schema 2020-12). Pass
 *   {@link openapi31Dialect} or {@link oas30Dialect} for the OpenAPI
 *   keyword sets.
 * @returns A read-only map; the returned identity is memoized per
 *   dialect, so repeated calls with the same dialect return the same
 *   object.
 *
 * @public
 */
declare function keywordDefinitions(dialect?: Dialect): ReadonlyMap<string, KeywordDefinition>;

export { APPLICATOR_VOCAB, CONTENT_VOCAB, CORE_VALIDATION_VOCAB, CORE_VOCAB, Dialect, FORMAT_ASSERTION_VOCAB, FORMAT_VOCAB, KeywordDefinition, META_DATA_VOCAB, OAS30_VOCAB, OPENAPI_META_DATA_VOCAB, UNEVALUATED_VOCAB, Vocabulary, additionalPropertiesKeyword, allOfKeyword, anchorKeyword, anyOfKeyword, applicatorVocabulary, commentKeyword, constKeyword, containsKeyword, contentEncodingKeyword, contentMediaTypeKeyword, contentSchemaKeyword, contentVocabulary, coreVocabulary, defaultKeyword, defaultVocabularies, defsKeyword, dependenciesKeyword, dependentRequiredKeyword, dependentSchemasKeyword, deprecatedKeyword, descriptionKeyword, discriminatorKeyword, dynamicAnchorKeyword, dynamicRefKeyword, enumKeyword, exampleKeyword, examplesKeyword, exclusiveMaximumKeyword, exclusiveMinimumKeyword, externalDocsKeyword, formatAssertionKeyword, formatAssertionVocabulary, formatKeyword, formatVocabulary, idKeyword, ifThenElseKeyword, itemsKeyword, jsonSchemaDialect, keywordDefinitions, maxItemsKeyword, maxLengthKeyword, maxPropertiesKeyword, maximumKeyword, metaDataVocabulary, minItemsKeyword, minLengthKeyword, minPropertiesKeyword, minimumKeyword, multipleOfKeyword, notKeyword, oas30Dialect, oas30ExclusiveMaximumKeyword, oas30ExclusiveMinimumKeyword, oas30MaximumKeyword, oas30MinimumKeyword, oas30NullableKeyword, oas30TypeKeyword, oas30Vocabulary, oneOfKeyword, openapi31Dialect, openapiMetaDataVocabulary, patternKeyword, patternPropertiesKeyword, prefixItemsKeyword, propertiesKeyword, propertyNamesKeyword, readOnlyKeyword, refKeyword, requiredKeyword, schemaDialectKeyword, titleKeyword, typeKeyword, unevaluatedItemsKeyword, unevaluatedPropertiesKeyword, unevaluatedVocabulary, uniqueItemsKeyword, validationVocabulary, writeOnlyKeyword, xmlKeyword };