@kubb/agent 5.0.0-beta.4 → 5.0.0-beta.6

package/.output/server/node_modules/ajv/lib/refs/json-schema-draft-04.json

@@ -0,0 +1,138 @@
+{
+  "id": "http://json-schema.org/draft-04/schema#",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "Core schema meta-schema",
+  "definitions": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": {"$ref": "#"}
+    },
+    "positiveInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "positiveIntegerDefault0": {
+      "allOf": [{"$ref": "#/definitions/positiveInteger"}, {"default": 0}]
+    },
+    "simpleTypes": {
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": {"type": "string"},
+      "minItems": 1,
+      "uniqueItems": true
+    }
+  },
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "format": "uri"
+    },
+    "$schema": {
+      "type": "string",
+      "format": "uri"
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "default": {},
+    "multipleOf": {
+      "type": "number",
+      "minimum": 0,
+      "exclusiveMinimum": true
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "boolean",
+      "default": false
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxLength": {"$ref": "#/definitions/positiveInteger"},
+    "minLength": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "additionalItems": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "items": {
+      "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/schemaArray"}],
+      "default": {}
+    },
+    "maxItems": {"$ref": "#/definitions/positiveInteger"},
+    "minItems": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxProperties": {"$ref": "#/definitions/positiveInteger"},
+    "minProperties": {"$ref": "#/definitions/positiveIntegerDefault0"},
+    "required": {"$ref": "#/definitions/stringArray"},
+    "additionalProperties": {
+      "anyOf": [{"type": "boolean"}, {"$ref": "#"}],
+      "default": {}
+    },
+    "definitions": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "properties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": {"$ref": "#"},
+      "default": {}
+    },
+    "dependencies": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [{"$ref": "#"}, {"$ref": "#/definitions/stringArray"}]
+      }
+    },
+    "enum": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true
+    },
+    "type": {
+      "anyOf": [
+        {"$ref": "#/definitions/simpleTypes"},
+        {
+          "type": "array",
+          "items": {"$ref": "#/definitions/simpleTypes"},
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    },
+    "allOf": {"$ref": "#/definitions/schemaArray"},
+    "anyOf": {"$ref": "#/definitions/schemaArray"},
+    "oneOf": {"$ref": "#/definitions/schemaArray"},
+    "not": {"$ref": "#"}
+  },
+  "dependencies": {
+    "exclusiveMaximum": ["maximum"],
+    "exclusiveMinimum": ["minimum"]
+  },
+  "default": {}
+}

package/.output/server/node_modules/ajv/lib/types/index.ts

@@ -242,3 +242,7 @@ export interface UriResolver {
   resolve(base: string, path: string): string
   serialize(component: URIComponent): string
 }
+
+export interface Context {
+  apiContext?: "request" | "response"
+}

package/.output/server/node_modules/ajv/lib/vocabularies/applicator/additionalProperties.ts

@@ -30,7 +30,8 @@ const def: CodeKeywordDefinition & AddedKeywordDefinition = {
   trackErrors: true,
   error,
   code(cxt) {
-    const {gen, schema, parentSchema, data, errsCount, it} = cxt
+    const {gen, parentSchema, data, errsCount, it} = cxt
+    const {schema = it.opts.defaultAdditionalProperties} = cxt
     /* istanbul ignore if */
     if (!errsCount) throw new Error("ajv implementation error")
     const {allErrors, opts} = it

package/.output/server/node_modules/ajv/lib/vocabularies/applicator/allOf.ts

@@ -12,7 +12,7 @@ const def: CodeKeywordDefinition = {
     const valid = gen.name("valid")
     schema.forEach((sch: AnySchema, i: number) => {
       if (alwaysValidSchema(it, sch)) return
-      const schCxt = cxt.subschema({keyword: "allOf", schemaProp: i}, valid)
+      const schCxt = cxt.subschema({keyword: "allOf", schemaProp: i}, valid, true)
       cxt.ok(valid)
       cxt.mergeEvaluated(schCxt)
     })

package/.output/server/node_modules/ajv/lib/vocabularies/applicator/properties.ts

@@ -10,7 +10,10 @@ const def: CodeKeywordDefinition = {
   schemaType: "object",
   code(cxt: KeywordCxt) {
     const {gen, schema, parentSchema, data, it} = cxt
-    if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) {
+    if (
+      (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) ||
+      it.opts.defaultAdditionalProperties === false
+    ) {
       apDef.code(new KeywordCxt(it, apDef, "additionalProperties"))
     }
     const allProps = allSchemaProperties(schema)

package/.output/server/node_modules/ajv/lib/vocabularies/code.ts

@@ -5,6 +5,7 @@ import {CodeGen, _, and, or, not, nil, strConcat, getProperty, Code, Name} from
 import {alwaysValidSchema, Type} from "../compile/util"
 import N from "../compile/names"
 import {useFunc} from "../compile/util"
+import {getSkipCondition} from "./oasContext"
 export function checkReportMissingProp(cxt: KeywordCxt, prop: string): void {
   const {gen, data, it} = cxt
   gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
@@ -14,13 +15,17 @@ export function checkReportMissingProp(cxt: KeywordCxt, prop: string): void {
 }
 
 export function checkMissingProp(
-  {gen, data, it: {opts}}: KeywordCxt,
+  {gen, data, it: {opts}, parentSchema}: KeywordCxt,
   properties: string[],
   missing: Name
 ): Code {
   return or(
     ...properties.map((prop) =>
-      and(noPropertyInData(gen, data, prop, opts.ownProperties), _`${missing} = ${prop}`)
+      and(
+        not(getSkipCondition(parentSchema, prop) ?? _`false`),
+        noPropertyInData(gen, data, prop, opts.ownProperties),
+        _`${missing} = ${prop}`
+      )
     )
   )
 }
@@ -84,6 +89,7 @@ export function callValidateCode(
     [N.parentData, it.parentData],
     [N.parentDataProperty, it.parentDataProperty],
     [N.rootData, N.rootData],
+    [N.isAllOfVariant, it.isAllOfVariant ? 1 : 0],
   ]
   if (it.opts.dynamicRef) valCxt.push([N.dynamicAnchors, N.dynamicAnchors])
   const args = _`${dataAndSchema}, ${gen.object(...valCxt)}`
@@ -133,9 +139,10 @@ export function validateArray(cxt: KeywordCxt): Name {
 }
 
 export function validateUnion(cxt: KeywordCxt): void {
-  const {gen, schema, keyword, it} = cxt
+  const {gen, schema, keyword, parentSchema, it} = cxt
   /* istanbul ignore if */
   if (!Array.isArray(schema)) throw new Error("ajv implementation error")
+  if (it.opts.discriminator && parentSchema.discriminator) return
   const alwaysValid = schema.some((sch: AnySchema) => alwaysValidSchema(it, sch))
   if (alwaysValid && !it.opts.unevaluated) return
 

package/.output/server/node_modules/ajv/lib/vocabularies/core/ref.ts

@@ -45,7 +45,8 @@ const def: CodeKeywordDefinition = {
           topSchemaRef: schName,
           errSchemaPath: $ref,
         },
-        valid
+        valid,
+        it.isAllOfVariant // pass isAllOfVariant into inlined $ref
       )
       cxt.mergeEvaluated(schCxt)
       cxt.ok(valid)
@@ -86,11 +87,26 @@ export function callRef(cxt: KeywordCxt, v: Code, sch?: SchemaEnv, $async?: bool
   }
 
   function callSyncRef(): void {
-    cxt.result(
-      callValidateCode(cxt, v, passCxt),
-      () => addEvaluatedFrom(v),
-      () => addErrorsFrom(v)
+    const visitedNodes: Name = gen.name("visitedNodes")
+    gen.code(
+      _`const ${visitedNodes} = (typeof visitedNodesForRef !== 'undefined') && visitedNodesForRef.get(${v}) || new Set()`
     )
+    gen.if(_`!${visitedNodes}.has(${cxt.data})`, () => {
+      gen.code(
+        _`if (typeof visitedNodesForRef !== 'undefined') visitedNodesForRef.set(${v}, ${visitedNodes})`
+      )
+      gen.code(_`const dataNode = ${cxt.data}`)
+      gen.code(
+        _`if (typeof dataNode === "object" && dataNode !== null) ${visitedNodes}.add(dataNode)`
+      )
+      const res = cxt.result(
+        callValidateCode(cxt, v, passCxt),
+        () => addEvaluatedFrom(v),
+        () => addErrorsFrom(v)
+      )
+      gen.code(_`${visitedNodes}.delete(dataNode)`)
+      return res
+    })
   }
 
   function addErrorsFrom(source: Code): void {

package/.output/server/node_modules/ajv/lib/vocabularies/discriminator/index.ts

@@ -12,11 +12,28 @@ const error: KeywordErrorDefinition = {
   message: ({params: {discrError, tagName}}) =>
     discrError === DiscrError.Tag
       ? `tag "${tagName}" must be string`
-      : `value of tag "${tagName}" must be in oneOf`,
+      : `value of tag "${tagName}" must be in oneOf or anyOf`,
   params: ({params: {discrError, tag, tagName}}) =>
     _`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`,
 }
 
+function getDiscriminatorPropertyFromAllOf(
+  sch: AnySchemaObject,
+  tagName: string
+): AnySchemaObject | undefined {
+  if (!sch.allOf || !Array.isArray(sch.allOf)) {
+    return undefined
+  }
+
+  for (const subschema of sch.allOf) {
+    if (subschema?.properties?.[tagName]) {
+      return subschema.properties[tagName] as AnySchemaObject
+    }
+  }
+
+  return undefined
+}
+
 const def: CodeKeywordDefinition = {
   keyword: "discriminator",
   type: "object",
@@ -24,14 +41,16 @@ const def: CodeKeywordDefinition = {
   error,
   code(cxt: KeywordCxt) {
     const {gen, data, schema, parentSchema, it} = cxt
-    const {oneOf} = parentSchema
+
+    const keyword = parentSchema.oneOf ? "oneOf" : parentSchema.anyOf ? "anyOf" : undefined
+
     if (!it.opts.discriminator) {
       throw new Error("discriminator: requires discriminator option")
     }
     const tagName = schema.propertyName
     if (typeof tagName != "string") throw new Error("discriminator: requires propertyName")
-    if (schema.mapping) throw new Error("discriminator: mapping is not supported")
-    if (!oneOf) throw new Error("discriminator: requires oneOf keyword")
+    if (!keyword) throw new Error("discriminator: requires oneOf or anyOf composite keyword")
+    const parentSchemaVariants = parentSchema[keyword]
     const valid = gen.let("valid", false)
     const tag = gen.const("tag", _`${data}${getProperty(tagName)}`)
     gen.if(
@@ -55,37 +74,68 @@ const def: CodeKeywordDefinition = {
 
     function applyTagSchema(schemaProp?: number): Name {
       const _valid = gen.name("valid")
-      const schCxt = cxt.subschema({keyword: "oneOf", schemaProp}, _valid)
+      const schCxt = cxt.subschema({keyword, schemaProp}, _valid)
       cxt.mergeEvaluated(schCxt, Name)
       return _valid
     }
 
     function getMapping(): {[T in string]?: number} {
-      const oneOfMapping: {[T in string]?: number} = {}
+      const discriminatorMapping: {[T in string]?: number} = {}
       const topRequired = hasRequired(parentSchema)
       let tagRequired = true
-      for (let i = 0; i < oneOf.length; i++) {
-        let sch = oneOf[i]
-        if (sch?.$ref && !schemaHasRulesButRef(sch, it.self.RULES)) {
-          const ref = sch.$ref
-          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref)
+      for (let i = 0; i < parentSchemaVariants.length; i++) {
+        let sch = parentSchemaVariants[i]
+        const schRef = sch?.$ref
+
+        if (schRef && schema.mapping) {
+          const {mapping} = schema
+          const matchedKeys = Object.keys(mapping).filter((key) => mapping[key] === sch.$ref)
+
+          if (matchedKeys.length) {
+            for (const key of matchedKeys) {
+              addMapping(key, i)
+            }
+            continue
+          }
+        }
+
+        if (schRef && !schemaHasRulesButRef(sch, it.self.RULES)) {
+          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, schRef)
           if (sch instanceof SchemaEnv) sch = sch.schema
-          if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, ref)
+          if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, schRef)
         }
-        const propSch = sch?.properties?.[tagName]
+
+        let propSch = sch?.properties?.[tagName]
+        if (!propSch && sch?.allOf) {
+          propSch = getDiscriminatorPropertyFromAllOf(sch, tagName)
+        }
+
         if (typeof propSch != "object") {
           throw new Error(
-            `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`
+            `discriminator: ${keyword} subschemas (or referenced schemas) must have "properties/${tagName}" or match mapping`
           )
         }
         tagRequired = tagRequired && (topRequired || hasRequired(sch))
         addMappings(propSch, i)
       }
       if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`)
-      return oneOfMapping
+      return discriminatorMapping
+
+      function hasRequired(sch: AnySchemaObject): boolean {
+        if (Array.isArray(sch.required) && sch.required.includes(tagName)) {
+          return true
+        }
+
+        if (sch.allOf && Array.isArray(sch.allOf)) {
+          for (const subschema of sch.allOf) {
+            const subSch = subschema as AnySchemaObject
+            if (Array.isArray(subSch.required) && subSch.required.includes(tagName)) {
+              return true
+            }
+          }
+        }
 
-      function hasRequired({required}: AnySchemaObject): boolean {
-        return Array.isArray(required) && required.includes(tagName)
+        return false
       }
 
       function addMappings(sch: AnySchemaObject, i: number): void {
@@ -101,10 +151,10 @@ const def: CodeKeywordDefinition = {
       }
 
       function addMapping(tagValue: unknown, i: number): void {
-        if (typeof tagValue != "string" || tagValue in oneOfMapping) {
+        if (typeof tagValue != "string" || tagValue in discriminatorMapping) {
           throw new Error(`discriminator: "${tagName}" values must be unique strings`)
         }
-        oneOfMapping[tagValue] = i
+        discriminatorMapping[tagValue] = i
       }
     }
   },

package/.output/server/node_modules/ajv/lib/vocabularies/draft4.ts

@@ -0,0 +1,32 @@
+import {Vocabulary} from "../types"
+import refKeyword from "./core/ref"
+import getApplicatorVocabulary from "./applicator"
+import unevaluatedVocabulary from "./unevaluated"
+import formatVocabulary from "./format"
+import validationVocabulary from "./validation"
+import limitNumber from "./validation/draft04/limitNumber"
+import limitNumberExclusive from "./validation/draft04/limitNumberExclusive"
+
+const metadataVocabulary: Vocabulary = ["title", "description", "default"]
+
+const coreVocabulary: Vocabulary = [
+  "$schema",
+  "id",
+  "$defs",
+  {keyword: "$comment"},
+  "definitions",
+  refKeyword,
+]
+
+const validation: Vocabulary = [...validationVocabulary.slice(1), limitNumber, limitNumberExclusive]
+
+const draft4Vocabularies: Vocabulary[] = [
+  coreVocabulary,
+  validation,
+  getApplicatorVocabulary(),
+  formatVocabulary,
+  metadataVocabulary,
+  unevaluatedVocabulary,
+]
+
+export default draft4Vocabularies

package/.output/server/node_modules/ajv/lib/vocabularies/metadata.ts

@@ -5,8 +5,16 @@ export const metadataVocabulary: Vocabulary = [
   "description",
   "default",
   "deprecated",
-  "readOnly",
-  "writeOnly",
+  /**
+   * readOnly/writeOnly are handled as validation keywords when OAS context is provided.
+   * Keeping them here would register them as annotation-only metadata and would
+   * prevent the context-aware validation behavior.
+   *
+   * @see ./validation/readOnly.ts
+   * @see ./validation/writeOnly.ts
+   */
+  // "readOnly",
+  // "writeOnly",
   "examples",
 ]
 

package/.output/server/node_modules/ajv/lib/vocabularies/oasContext.ts

@@ -0,0 +1,27 @@
+import type {AnySchemaObject} from "../types"
+
+import {_, or, type Code} from "../compile/codegen"
+import N from "../compile/names"
+
+export function getSkipCondition(schema: AnySchemaObject, prop: string): Code | undefined {
+  const propSchema = schema.properties?.[prop]
+  if (!propSchema) return undefined
+
+  const hasReadOnly = propSchema.readOnly === true
+  const hasWriteOnly = propSchema.writeOnly === true
+
+  if (!hasReadOnly && !hasWriteOnly) return undefined
+
+  const conditions: Code[] = []
+  const apiContext = _`typeof ${N.this} == "object" && ${N.this} && ${N.this}.apiContext`
+
+  if (hasReadOnly) {
+    conditions.push(_`${apiContext} === "request"`)
+  }
+
+  if (hasWriteOnly) {
+    conditions.push(_`${apiContext} === "response"`)
+  }
+
+  return or(...conditions)
+}

package/.output/server/node_modules/ajv/lib/vocabularies/unevaluated/unevaluatedProperties.ts

@@ -23,10 +23,12 @@ const def: CodeKeywordDefinition = {
   keyword: "unevaluatedProperties",
   type: "object",
   schemaType: ["boolean", "object"],
+  allowUndefined: true,
   trackErrors: true,
   error,
   code(cxt) {
-    const {gen, schema, data, errsCount, it} = cxt
+    const {gen, schema = cxt.it.opts.defaultUnevaluatedProperties, data, errsCount, it} = cxt
+    const isForced = cxt.schema === undefined && cxt.it.opts.defaultUnevaluatedProperties === false
     /* istanbul ignore if */
     if (!errsCount) throw new Error("ajv implementation error")
     const {allErrors, props} = it
@@ -37,13 +39,33 @@ const def: CodeKeywordDefinition = {
         )
       )
     } else if (props !== true) {
-      gen.forIn("key", data, (key: Name) =>
-        props === undefined
-          ? unevaluatedPropCode(key)
-          : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key))
-      )
+      // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+      const staticCheck = () =>
+        gen.forIn("key", data, (key: Name) =>
+          props === undefined
+            ? unevaluatedPropCode(key)
+            : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key))
+        )
+
+      if (isForced && it.errorPath.emptyStr() && !it.compositeRule) {
+        // $refs are compiled into functions
+        // We need to check in runtime if function was called from allOf.
+        // We need to check only on the top level of the function:
+        // it is ensured with `it.errorPath.emptyStr()` check
+        gen.if(_`${N.isAllOfVariant} === 0`, staticCheck)
+      } else {
+        if (!it.compositeRule || cxt.schema !== undefined) {
+          staticCheck()
+        }
+      }
+    }
+
+    if (!isForced) {
+      // disable shot-circut for forced unevaluatedProperties=false
+      // we may run or not the check in runtime so we can't short-circuit in compile-time
+      it.props = true
     }
-    it.props = true
+
     cxt.ok(_`${errsCount} === ${N.errors}`)
 
     function unevaluatedPropCode(key: Name): void {

package/.output/server/node_modules/ajv/lib/vocabularies/validation/draft04/limitNumber.ts

@@ -0,0 +1,75 @@
+import type {
+  CodeKeywordDefinition,
+  ErrorObject,
+  KeywordErrorDefinition,
+  KeywordErrorCxt,
+} from "../../../types"
+import type {KeywordCxt} from "../../../compile/validate"
+import {_, str, operators, Code} from "../../../compile/codegen"
+
+const ops = operators
+
+export type LimitKwd = "maximum" | "minimum"
+
+export type ExclusiveLimitKwd = "exclusiveMaximum" | "exclusiveMinimum"
+
+type Comparison = "<=" | ">=" | "<" | ">"
+
+interface KwdOp {
+  okStr: Comparison
+  ok: Code
+  fail: Code
+}
+
+interface KwdDef {
+  exclusive: ExclusiveLimitKwd
+  ops: [KwdOp, KwdOp]
+}
+
+const KWDs: {[K in LimitKwd]: KwdDef} = {
+  maximum: {
+    exclusive: "exclusiveMaximum",
+    ops: [
+      {okStr: "<=", ok: ops.LTE, fail: ops.GT},
+      {okStr: "<", ok: ops.LT, fail: ops.GTE},
+    ],
+  },
+  minimum: {
+    exclusive: "exclusiveMinimum",
+    ops: [
+      {okStr: ">=", ok: ops.GTE, fail: ops.LT},
+      {okStr: ">", ok: ops.GT, fail: ops.LTE},
+    ],
+  },
+}
+
+export type LimitNumberError = ErrorObject<
+  LimitKwd,
+  {limit: number; comparison: Comparison},
+  number | {$data: string}
+>
+
+const error: KeywordErrorDefinition = {
+  message: (cxt) => str`must be ${kwdOp(cxt).okStr} ${cxt.schemaCode}`,
+  params: (cxt) => _`{comparison: ${kwdOp(cxt).okStr}, limit: ${cxt.schemaCode}}`,
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: Object.keys(KWDs),
+  type: "number",
+  schemaType: "number",
+  $data: true,
+  error,
+  code(cxt: KeywordCxt) {
+    const {data, schemaCode} = cxt
+    cxt.fail$data(_`${data} ${kwdOp(cxt).fail} ${schemaCode} || isNaN(${data})`)
+  },
+}
+
+function kwdOp(cxt: KeywordErrorCxt): KwdOp {
+  const keyword = cxt.keyword as LimitKwd
+  const opsIdx = cxt.parentSchema?.[KWDs[keyword].exclusive] ? 1 : 0
+  return KWDs[keyword].ops[opsIdx]
+}
+
+export default def

package/.output/server/node_modules/ajv/lib/vocabularies/validation/draft04/limitNumberExclusive.ts

@@ -0,0 +1,26 @@
+import type {
+  CodeKeywordDefinition,
+  // ErrorObject,
+  // KeywordErrorDefinition,
+} from "../../../types"
+import type {KeywordCxt} from "../../../compile/validate"
+import {LimitKwd, ExclusiveLimitKwd} from "./limitNumber"
+
+const KWDs: {[K in ExclusiveLimitKwd]: LimitKwd} = {
+  exclusiveMaximum: "maximum",
+  exclusiveMinimum: "minimum",
+}
+
+const def: CodeKeywordDefinition = {
+  keyword: Object.keys(KWDs),
+  type: "number",
+  schemaType: "boolean",
+  code({keyword, parentSchema}: KeywordCxt) {
+    const limitKwd = KWDs[keyword as ExclusiveLimitKwd]
+    if (parentSchema[limitKwd] === undefined) {
+      throw new Error(`${keyword} can only be used with ${limitKwd}`)
+    }
+  },
+}
+
+export default def

package/.output/server/node_modules/ajv/lib/vocabularies/validation/index.ts

@@ -5,6 +5,8 @@ import limitLength from "./limitLength"
 import pattern, {PatternError} from "./pattern"
 import limitProperties from "./limitProperties"
 import required, {RequiredError} from "./required"
+import readOnlyKeyword from "./readOnly"
+import writeOnlyKeyword from "./writeOnly"
 import limitItems from "./limitItems"
 import uniqueItems, {UniqueItemsError} from "./uniqueItems"
 import constKeyword, {ConstError} from "./const"
@@ -20,6 +22,8 @@ const validation: Vocabulary = [
   // object
   limitProperties,
   required,
+  readOnlyKeyword,
+  writeOnlyKeyword,
   // array
   limitItems,
   uniqueItems,