oas 38.5.2 → 38.6.0

package/dist/chunk-OBYCSKPS.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/darrenyong/Desktop/oas-stuff/oas/packages/oas/dist/chunk-OBYCSKPS.cjs","../src/lib/matches-mimetype.ts","../src/lib/get-parameter-content-type.ts","../src/lib/refs.ts","../src/lib/helpers.ts","../src/lib/clone-object.ts","../src/lib/build-discriminator-one-of.ts","../src/lib/openapi-to-json-schema.ts","../src/operation/transformers/get-parameters-as-json-schema.ts","../src/utils.ts"],"names":["types","converted","schema"],"mappings":"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","file":"/Users/darrenyong/Desktop/oas-stuff/oas/packages/oas/dist/chunk-OBYCSKPS.cjs","sourcesContent":[null,"function matchesMediaType(types: string[], mediaType: string): boolean {\n  return types.some(type => {\n    return mediaType.indexOf(type) > -1;\n  });\n}\n\nexport default {\n  formUrlEncoded: (mimeType: string): boolean => {\n    return matchesMediaType(['application/x-www-form-urlencoded'], mimeType);\n  },\n\n  json: (contentType: string): boolean => {\n    return matchesMediaType(\n      ['application/json', 'application/x-json', 'text/json', 'text/x-json', '+json'],\n      contentType,\n    );\n  },\n\n  multipart: (contentType: string): boolean => {\n    return matchesMediaType(\n      ['multipart/mixed', 'multipart/related', 'multipart/form-data', 'multipart/alternative'],\n      contentType,\n    );\n  },\n\n  wildcard: (contentType: string): boolean => {\n    return contentType === '*/*';\n  },\n\n  xml: (contentType: string): boolean => {\n    return matchesMediaType(\n      [\n        'application/xml',\n        'application/xml-external-parsed-entity',\n        'application/xml-dtd',\n        'text/xml',\n        'text/xml-external-parsed-entity',\n        '+xml',\n      ],\n      contentType,\n    );\n  },\n};\n","import matchesMimetype from './matches-mimetype.js';\n\n/**\n * Selects a content type from an array of content type keys, prioritizing `application/json`\n * and other JSON-like content types over other content types.\n *\n * When multiple content types are present:\n * - If there's exactly one content type, it's returned\n * - If there are multiple content types, JSON-like content types (e.g., `application/json`,\n *   `application/vnd.api+json`) are prioritized\n * - If no JSON-like content types are present, the first content type is returned\n *\n * @param contentKeys - Array of content type keys (e.g., ['application/json', 'application/xml'])\n * @returns The selected content type, or undefined if the array is empty\n */\nexport function getParameterContentType(contentKeys: string[]): string | undefined {\n  if (contentKeys.length === 0) {\n    return undefined;\n  }\n\n  if (contentKeys.length === 1) {\n    return contentKeys[0];\n  }\n\n  // We should always try to prioritize `application/json` over any other possible\n  // content that might be present on this schema.\n  const jsonLikeContentTypes = contentKeys.filter(k => matchesMimetype.json(k));\n  if (jsonLikeContentTypes.length) {\n    return jsonLikeContentTypes[0];\n  }\n\n  return contentKeys[0];\n}\n","import type { OASDocument, SchemaObject } from '../types.js';\n\nimport jsonpointer from 'jsonpointer';\n\nimport { isRef } from '../types.js';\n\nimport { isPrimitive } from './helpers.js';\n\n/**\n * Normalize a `$ref` pointer (`#/components/schemas/Pet`) into a plain JSON pointer\n * (`/components/schemas/Pet`) so it can be compared against `jsonpath-plus` result pointers, which\n * never carry the leading `#`.\n *\n */\nexport function toPointer($ref: string): string {\n  return $ref.startsWith('#') ? $ref.slice(1) : $ref;\n}\n\n/**\n * Decorate component schemas within the API definition with a `x-readme-ref-name` property so we\n * can retin their original schema names during dereferencing or `$ref` resolution operations.\n *\n */\nexport function decorateComponentSchemasWithRefName(api: OASDocument): void {\n  if (!api?.components?.schemas || typeof api.components.schemas !== 'object') {\n    return;\n  }\n\n  Object.keys(api.components.schemas).forEach(schemaName => {\n    // As of OpenAPI 3.1 component schemas can be primitives or arrays. If this happens then we\n    // shouldn't try to add `x-readme-ref-name` properties because we can't. We'll have some data\n    // loss on these schemas but as they aren't objects they likely won't be used in ways that\n    // would require needing a `title` or `x-readme-ref-name` anyways.\n    if (\n      isPrimitive(api.components?.schemas?.[schemaName]) ||\n      Array.isArray(api.components?.schemas?.[schemaName]) ||\n      api.components?.schemas?.[schemaName] === null\n    ) {\n      return;\n    }\n\n    // oxlint-disable-next-line no-unsafe-optional-chaining\n    (api.components?.schemas?.[schemaName] as SchemaObject)['x-readme-ref-name'] = schemaName;\n  });\n}\n\n/**\n * Encode a string to be used as a JSON pointer.\n *\n * @see {@link https://tools.ietf.org/html/rfc6901}\n * @param str String to encode into string that can be used as a JSON pointer.\n */\nexport function encodePointer(str: string): string {\n  return str.replaceAll('~', '~0').replaceAll('/', '~1');\n}\n\n/**\n * Decode a JSON pointer string.\n *\n * Per RFC 6901, `~0` is unescaped to `~` and `~1` to `/`. A single-pass replacement is required:\n * the sequence `~01` must decode to `~1` (tilde then one), not `~/`. Replacing `~1` before `~0`\n * would incorrectly turn `~01` into `~/`.\n *\n * @see {@link https://tools.ietf.org/html/rfc6901}\n * @param str String to decode a JSON pointer from\n */\nexport function decodePointer(str: string): string {\n  return str.replace(/~([01])/g, (_, digit) => (digit === '0' ? '~' : '/'));\n}\n\n/**\n * Lookup a reference pointer within an a JSON object and return the schema that it resolves to.\n *\n * @param $ref Reference to look up a schema for.\n * @param definition OpenAPI definition to look for the `$ref` pointer in.\n */\nfunction findRef($ref: string, definition: OASDocument | SchemaObject): any {\n  let currRef = $ref.trim();\n  if (currRef === '') {\n    // If this ref is empty, don't bother trying to look for it.\n    return false;\n  }\n\n  if (currRef.startsWith('#')) {\n    // Decode URI fragment representation.\n    currRef = decodeURIComponent(currRef.substring(1));\n  } else {\n    throw new Error(`Could not find a definition for ${$ref}.`);\n  }\n\n  const current = jsonpointer.get(definition, currRef);\n  if (current === undefined) {\n    throw new Error(`Could not find a definition for ${$ref}.`);\n  }\n\n  return current;\n}\n\n/**\n * Dereference a `$ref` pointer if present, otherwise return the value as-is.\n *\n * This function handles `$ref` pointers on-the-fly without requiring full dereferencing and\n * prevents infinite loops by tracking seen `$ref` pointers and not re-processing circular\n * references.\n *\n * @param value The value that may contain a `$ref` pointer.\n * @param definition OpenAPI definition to look for the `$ref` pointer in.\n * @param seenRefs Optional Set to track `$ref` pointers that have already been processed to prevent circular references.\n * @returns The dereferenced value if it was a `$ref`, otherwise the original value. Returns the original `$ref` if it's circular.\n */\nexport function dereferenceRef<T>(\n  value: T,\n  definition?: OASDocument | SchemaObject,\n  seenRefs: Set<string> = new Set<string>(),\n): T {\n  if (value === undefined) {\n    return undefined as T;\n  }\n\n  if (isRef(value)) {\n    if (!definition) {\n      return value as T;\n    }\n\n    const ref = value.$ref;\n\n    // If we've seen this `$ref` before then it's circular and we should return the original `$ref`\n    // to prevent infinite loops\n    if (seenRefs.has(ref)) {\n      return value as T;\n    }\n\n    // Track this `$ref` as having been seen so we can avoid infinitely processing circular\n    // references.\n    seenRefs.add(ref);\n\n    try {\n      const dereferenced = findRef(ref, definition);\n\n      // If the dereferenced value is itself a `$ref` then recursively dereference it (but with\n      // `seenRefs` tracking).\n      if (isRef(dereferenced)) {\n        return dereferenceRef(dereferenced, definition, seenRefs) as T;\n      }\n\n      return {\n        ...dereferenced,\n      } as T;\n    } catch {\n      // If dereferencing fails return the original `$ref`.\n      return value as T;\n    }\n  }\n\n  return value;\n}\n\n/**\n * Recursively resolve `$ref` pointers inside a given schema.\n *\n * Uses the same `seenRefs` logic as `dereferenceRef` for protection against circular references.\n *\n * @see {@link dereferenceRef}\n */\nexport function dereferenceRefDeep<T>(\n  value: T,\n  definition?: OASDocument | SchemaObject,\n  seenRefs: Set<string> = new Set<string>(),\n): T {\n  if (value === null || value === undefined) return value;\n  if (typeof value !== 'object') return value;\n\n  if (isRef(value)) {\n    if (!definition) return value;\n\n    const resolved = dereferenceRef(value, definition, seenRefs);\n    if (isRef(resolved)) return resolved as T;\n\n    return dereferenceRefDeep(resolved, definition, seenRefs) as T;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map(entry => dereferenceRefDeep(entry, definition, seenRefs)) as T;\n  }\n\n  const out: Record<string, unknown> = {};\n  for (const key of Object.keys(value)) {\n    out[key] = dereferenceRefDeep((value as Record<string, unknown>)[key], definition, seenRefs);\n  }\n\n  return out as T;\n}\n\n/**\n * Recursively collect all `$ref` pointers in a schema.\n *\n */\nexport function collectRefsInSchema(schema: unknown): Set<string> {\n  const refs = new Set<string>();\n  if (!schema || typeof schema !== 'object') return refs;\n  const obj = schema as Record<string, unknown>;\n  if (isRef(obj)) {\n    refs.add(obj.$ref);\n  }\n\n  for (const value of Object.values(obj)) {\n    if (Array.isArray(value)) {\n      for (const item of value) {\n        for (const r of collectRefsInSchema(item)) refs.add(r);\n      }\n    } else if (value && typeof value === 'object') {\n      for (const r of collectRefsInSchema(value)) refs.add(r);\n    }\n  }\n\n  return refs;\n}\n\n/**\n * Given a set of `$ref` pointers and a full set of schema objects, mapped to their reference\n * locations, return only the schemas that are transitively referenced from those schemas.\n *\n */\nexport function filterRequiredRefsToReferenced(\n  requiredRefs: Set<string>,\n  usedSchemas: Map<string, SchemaObject>,\n): Map<string, SchemaObject> {\n  const referenced = new Set(requiredRefs);\n\n  let prevSize = 0;\n  while (referenced.size > prevSize) {\n    prevSize = referenced.size;\n    for (const ref of referenced) {\n      const schema = usedSchemas.get(ref);\n      if (schema) {\n        for (const r of collectRefsInSchema(schema)) {\n          referenced.add(r);\n        }\n      }\n    }\n  }\n\n  const filtered = new Map<string, SchemaObject>();\n  for (const ref of referenced) {\n    const s = usedSchemas.get(ref);\n    if (s !== undefined) {\n      filtered.set(ref, s);\n    }\n  }\n\n  return filtered;\n}\n\n/**\n * Parse a `$ref` pointers (e.g. `#/x-definitions/MySchema` or `#/components/schemas/Foo`) into\n * path segments. Returns `null` if the first segment is reserved (we should not embed at root\n * under that key).\n *\n */\nfunction getRefPathSegments(ref: string): string[] | null {\n  if (!ref.startsWith('#/')) return null;\n  const path = ref\n    .slice(2)\n    .split('/')\n    .map(seg => {\n      // We need to decode these segments twice because the first decode is to decode encoded JSON\n      // pointer segments, and the second is to decode any URI-encoded segments.\n      return decodeURIComponent(decodePointer(seg));\n    });\n\n  if (path.length < 2) {\n    // We need at least two pieces of a `$ref` for it to be valid. e.g. `#/x-definitions/MySchema`\n    // or `#/components/schemas/Foo`.\n    return null;\n  }\n\n  return path;\n}\n\nfunction isArrayIndexSegment(seg: string): boolean {\n  return /^\\d+$/.test(seg);\n}\n\nfunction childShouldBeSchemaArray(parentKey: string, childSeg: string | undefined): boolean {\n  if (!childSeg || !isArrayIndexSegment(childSeg)) {\n    return false;\n  }\n\n  return parentKey === 'allOf' || parentKey === 'anyOf' || parentKey === 'oneOf';\n}\n\n/**\n * Merge referenced schemas into the root schema at the paths defined by their reference location.\n *\n * @example `#/components/schemas/MySchema` -> `root.components.schemas.MySchema`\n */\nexport function mergeReferencedSchemasIntoRoot(root: SchemaObject, refToSchema: Map<string, unknown>): void {\n  // we need to sort this so parent schemas are placed before child schemas to\n  // prevent a parent from overwriting a child's synthetically created path\n  // sorting by path depth (shallowest first)\n  const sortedEntries = [...refToSchema.entries()].toSorted((a, b) => {\n    const aDepth = a[0].split('/').length;\n    const bDepth = b[0].split('/').length;\n    return aDepth - bDepth;\n  });\n\n  for (const [ref, schema] of sortedEntries) {\n    const segments = getRefPathSegments(ref);\n    if (!segments || segments.length === 0) {\n      continue;\n    }\n\n    let current: SchemaObject = root;\n    let pathInvalid = false;\n\n    for (let i = 0; i < segments.length - 1; i++) {\n      const seg = segments[i] as keyof SchemaObject;\n      const nextSeg = segments[i + 1];\n\n      if (Array.isArray(current)) {\n        const idx = Number(seg);\n        if (!Number.isInteger(idx) || idx < 0) {\n          pathInvalid = true;\n          break;\n        }\n\n        const slot: SchemaObject = current[idx];\n        if (slot === undefined || slot === null || typeof slot !== 'object' || Array.isArray(slot)) {\n          const nextObj: SchemaObject = {};\n          current[idx] = nextObj;\n          current = nextObj;\n        } else {\n          current = slot;\n        }\n\n        continue;\n      }\n\n      const cur = current;\n      const existing = cur[seg] as SchemaObject;\n\n      if (childShouldBeSchemaArray(seg, nextSeg)) {\n        if (!Array.isArray(existing)) {\n          cur[seg] = [];\n        }\n\n        current = cur[seg] as unknown[];\n        continue;\n      }\n\n      let next: Record<string, unknown>;\n      if (existing !== undefined && existing !== null && typeof existing === 'object' && !Array.isArray(existing)) {\n        next = existing as Record<string, unknown>;\n      } else {\n        next = {};\n        cur[seg] = next;\n      }\n\n      current = next;\n    }\n\n    if (pathInvalid) {\n      continue;\n    }\n\n    const lastSeg = segments[segments.length - 1] as keyof SchemaObject;\n    if (Array.isArray(current)) {\n      const idx = Number(lastSeg);\n      if (!Number.isInteger(idx) || idx < 0) {\n        continue;\n      }\n\n      current[idx] = schema;\n    } else {\n      current[lastSeg] = schema;\n    }\n  }\n}\n","import type { SchemaObject } from '../types.js';\n\nexport function hasSchemaType(schema: SchemaObject, discriminator: 'array' | 'object'): boolean {\n  if (Array.isArray(schema.type)) {\n    return schema.type.includes(discriminator);\n  }\n\n  return schema.type === discriminator;\n}\n\nexport function isObject(val: unknown): val is Record<string, unknown> {\n  return typeof val === 'object' && val !== null && !Array.isArray(val);\n}\n\nexport function isPrimitive(val: unknown): val is boolean | number | string {\n  return typeof val === 'string' || typeof val === 'number' || typeof val === 'boolean';\n}\n","/**\n * @deprecated Use `structuredClone` instead\n */\nexport function cloneObject<T>(obj: T): T {\n  if (typeof obj === 'undefined') {\n    return undefined as T;\n  }\n\n  // oxlint-disable-next-line readme/json-parse-try-catch\n  return JSON.parse(JSON.stringify(obj));\n}\n","import type { DiscriminatorChildrenMap, DiscriminatorObject, OASDocument, SchemaObject } from '../types.js';\n\nimport { isRef } from '../types.js';\n\nimport { cloneObject } from './clone-object.js';\nimport { decodePointer, encodePointer } from './refs.js';\n\n/**\n * Determines if a schema has a discriminator but is missing oneOf/anyOf polymorphism.\n *\n * @param schema Schema to check.\n * @returns If the schema has a discriminator but no oneOf/anyOf.\n */\nfunction hasDiscriminatorWithoutPolymorphism(schema: SchemaObject): boolean {\n  if (!schema || typeof schema !== 'object') return false;\n  if (!('discriminator' in schema)) return false;\n  if ('oneOf' in schema || 'anyOf' in schema) return false;\n  return true;\n}\n\n/**\n * Checks if a schema's allOf contains a $ref to a specific schema name.\n *\n * @param schema Schema to check.\n * @param targetSchemaName The schema name to look for (e.g., 'Pet').\n * @returns If the schema's allOf contains a $ref to the target schema.\n */\nfunction allOfReferencesSchema(schema: SchemaObject, targetSchemaName: string): boolean {\n  if (!schema || typeof schema !== 'object') return false;\n  if (!('allOf' in schema) || !Array.isArray(schema.allOf)) return false;\n\n  return schema.allOf.some(item => {\n    if (isRef(item)) {\n      // Check if the $ref points to the target schema\n      // Format: #/components/schemas/SchemaName\n      const refParts = item.$ref.split('/');\n      const refSchemaName = decodePointer(refParts[refParts.length - 1]);\n      return refSchemaName === targetSchemaName;\n    }\n\n    return false;\n  });\n}\n\n/**\n * Phase 1: Before dereferencing, identify discriminator schemas and their children via allOf\n * inheritance. Returns a mapping that can be used after dereferencing.\n *\n * We don't add oneOf here because that would create circular references\n * (Pet → Cat → Pet via allOf) which would break dereferencing.\n *\n * Note: Schemas defined in mapping but NOT declared using anyOf, allOf or oneOf will not be considered\n * a valid child. The discriminator object is legal only when using one of the composite keywords oneOf, anyOf, allOf.\n * @link https://spec.openapis.org/oas/v3.1.0.html#fixed-fields-20\n *\n * @param api The OpenAPI definition to process (before dereferencing).\n * @returns Maps of discriminator schema names to their child schema names and `$ref` pointers.\n */\nexport function findDiscriminatorChildren(definition: Pick<OASDocument, 'components'>): {\n  children: DiscriminatorChildrenMap;\n  refs: Map<string, string>;\n} {\n  const childrenMap: DiscriminatorChildrenMap = new Map();\n  const childrenRefMap = new Map<string, string>();\n\n  if (!definition?.components?.schemas || typeof definition.components.schemas !== 'object') {\n    return { children: childrenMap, refs: childrenRefMap };\n  }\n\n  const schemas = definition.components.schemas as Record<string, SchemaObject>;\n  const schemaNames = Object.keys(schemas);\n\n  // Find all schemas with discriminator but no oneOf/anyOf\n  const discriminatorSchemas: string[] = schemaNames.filter(name => {\n    return hasDiscriminatorWithoutPolymorphism(schemas[name]);\n  });\n\n  // For each discriminator schema, record child schema names\n  for (const baseName of discriminatorSchemas) {\n    const baseSchema = schemas[baseName] as SchemaObject & { discriminator: DiscriminatorObject };\n    const discriminator = baseSchema.discriminator;\n\n    let childSchemaNames: string[] = [];\n\n    // If there's already a mapping defined, use it but only include schemas that\n    // actually inherit from this parent via allOf. A mapping entry for a schema\n    // that doesn't use allOf is just a value resolution hint, not a declaration\n    // of inheritance.\n    if (discriminator.mapping && typeof discriminator.mapping === 'object') {\n      const mappingRefs = Object.values(discriminator.mapping);\n      if (mappingRefs.length > 0) {\n        childSchemaNames = mappingRefs\n          .map(value => {\n            // Bare schema names are literal keys; only decode names extracted from ref pointers.\n            if (Object.hasOwn(schemas, value)) {\n              return value;\n            }\n\n            const encodedName = value.split('/').pop() ?? '';\n            return decodePointer(encodedName);\n          })\n          .filter((name): name is string => {\n            if (!name) return false;\n            const childSchema = schemas[name];\n            return !!childSchema && allOfReferencesSchema(childSchema, baseName);\n          });\n      }\n    }\n\n    // Otherwise, scan for schemas that extend this base via allOf\n    if (!childSchemaNames.length) {\n      childSchemaNames = schemaNames.filter(name => {\n        if (name === baseName) return false;\n        return allOfReferencesSchema(schemas[name], baseName);\n      });\n    }\n\n    // Store child schema names in the map\n    if (childSchemaNames.length) {\n      for (const childName of childSchemaNames) {\n        childrenRefMap.set(childName, `#/components/schemas/${encodePointer(childName)}`);\n      }\n\n      childrenMap.set(baseName, childSchemaNames);\n      childrenRefMap.set(baseName, `#/components/schemas/${encodePointer(baseName)}`);\n    }\n  }\n\n  return { children: childrenMap, refs: childrenRefMap };\n}\n\n/**\n * Apply discriminator oneOf to a map of used schemas (e.g. from `getParametersAsJSONSchema` and\n * `getResponseAsJSONSchema`). For each discriminator base in `usedSchemas`, it ensures children\n * are in the map via `getOrAddSchema`, then sets `oneOf` on the base.\n *\n * Optionally this also strips `oneOf` from the base when it appears inside a child's `allOf`\n * schema.\n *\n * @param api The OpenAPI definition (for findDiscriminatorChildren).\n * @param usedSchemas Map of schema name -> JSON Schema to update.\n * @param getOrAddSchema Callback that resolves, converts, and adds a schema by name; returns the converted schema or undefined.\n */\nexport function applyDiscriminatorOneOfToUsedSchemas(\n  definition: Pick<OASDocument, 'components'>,\n  usedSchemas: Map<string, SchemaObject>,\n  getOrAddSchema: (ref: string) => SchemaObject | undefined,\n): void {\n  const { children: childrenMap, refs: childrenRefMap } = findDiscriminatorChildren(definition);\n  if (!childrenMap.size) return;\n\n  // Build oneOf for each discriminator schema\n  for (const [baseName, childNames] of childrenMap) {\n    const baseRef = childrenRefMap.get(baseName);\n    if (!baseRef) continue;\n\n    const baseSchema = usedSchemas.get(baseRef);\n    if (!baseSchema || typeof baseSchema !== 'object') continue;\n\n    // Build `oneOf` from raw child schema `$ref` pointers.\n    const oneOf: SchemaObject[] = [];\n    for (const childName of childNames) {\n      const childRef = childrenRefMap.get(childName);\n      if (!childRef) continue;\n\n      const childSchema = getOrAddSchema(childRef);\n      if (childSchema) {\n        oneOf.push({\n          $ref: childRef,\n        });\n      }\n    }\n\n    if (oneOf.length > 0) {\n      (baseSchema as Record<string, unknown>).oneOf = oneOf;\n    }\n  }\n\n  // Strip `oneOf` from discriminator schemas embedded in child `allOf` structures.\n  //\n  // When `Cat` extends `Pet` via an `allOf` and `Pet` has a `discriminator` with a `oneOf` the\n  // embedded `Pet` inside `Cat`'s `allOf` should NOT have `oneOf` because this would create a\n  // circular `Cat.allOf[0].oneOf[0] = Cat` reference.\n  //\n  // We only strip from `allOf` entries to preserve `oneOf` in direct references.\n  for (const [parentSchemaName, childNames] of childrenMap) {\n    for (const childName of childNames) {\n      const childRef = childrenRefMap.get(childName);\n      if (!childRef) continue;\n\n      const childSchema = usedSchemas.get(childRef);\n      if (!childSchema || !('allOf' in childSchema) || !Array.isArray(childSchema.allOf)) {\n        continue;\n      }\n\n      for (let i = 0; i < childSchema.allOf.length; i++) {\n        const item = childSchema.allOf[i];\n        if (\n          item &&\n          typeof item === 'object' &&\n          'x-readme-ref-name' in item &&\n          item['x-readme-ref-name'] === parentSchemaName &&\n          'oneOf' in item\n        ) {\n          // Clone the allOf entry and strip oneOf from the clone to avoid mutating the shared reference.\n          // This ensures Pet in components.schemas keeps its oneOf while embedded Pet in Cat's allOf doesn't.\n          const clonedItem = cloneObject(item);\n          delete clonedItem.oneOf;\n          childSchema.allOf[i] = clonedItem;\n        }\n      }\n    }\n  }\n}\n","import type {\n  ExampleObject,\n  JSONSchema,\n  OASDocument,\n  ReferenceObject,\n  RequestBodyObject,\n  SchemaObject,\n} from '../types.js';\nimport type { JSONSchema4, JSONSchema7TypeName } from 'json-schema';\nimport type { Options as JSONSchemaMergeAllOfOptions } from 'json-schema-merge-allof';\n\nimport mergeJSONSchemaAllOf from 'json-schema-merge-allof';\nimport jsonpointer from 'jsonpointer';\nimport removeUndefinedObjects from 'remove-undefined-objects';\n\nimport { isOpenAPI30, isRef, isSchema } from '../types.js';\n\nimport { hasSchemaType, isObject, isPrimitive } from './helpers.js';\nimport { collectRefsInSchema, dereferenceRef, encodePointer } from './refs.js';\n\n/**\n * This list has been pulled from `openapi-schema-to-json-schema` but been slightly modified to fit\n * within the constraints in which ReadMe uses the output from this library in schema form\n * rendering as while properties like `readOnly` aren't represented within JSON Schema, we support\n * it within that library's handling of OpenAPI-friendly JSON Schema.\n *\n * @see {@link https://github.com/openapi-contrib/openapi-schema-to-json-schema/blob/main/src/consts.ts}\n */\nconst UNSUPPORTED_SCHEMA_PROPS = [\n  'example', // OpenAPI supports `example` but we're mapping it to `examples` in this library.\n  'externalDocs',\n  'xml',\n] as const;\n\n/**\n * Annotation-only keywords we preserve when they appear as siblings of `$ref` inside `allOf`\n * properties. Validation keywords (`type`, `properties`, `items`, etc.) are intentionally\n * excluded, they would conflict with the resolved schema. `x-` extensions are also preserved\n * (handled separately at the call site).\n */\nconst METADATA_SIBLING_KEYS = new Set(['description', 'summary', 'title']);\n\nconst mergeAllOfSchemasOptions: JSONSchemaMergeAllOfOptions = {\n  ignoreAdditionalProperties: true,\n  resolvers: {\n    // `merge-json-schema-allof` by default takes the first `description` when you're merging an\n    // `allOf` but because generally when you're merging two schemas together with an `allOf` you\n    // want data in the subsequent schemas to be applied to the first and `description` should be a\n    // part of that.\n    description: (obj: string[]) => {\n      return obj.slice(-1)[0];\n    },\n\n    // `merge-json-schema-allof` doesn't support merging enum arrays but since that's a safe and\n    // simple operation as enums always contain primitives we can handle it ourselves with a custom\n    // resolver. We intersect the arrays so that child schemas can narrow a parent's broad enum\n    // (e.g. [1,2,20,50] ∩ [1] = [1]).\n    //\n    // We unfortunately need to cast our return value as `any[]` because the internal types of\n    // `merge-json-schema-allof`'s `enum` resolver are not portable.\n    enum: (obj: unknown[]) => {\n      const arrays = obj as any[][];\n      const intersection = arrays.reduce((acc, e) => acc.filter(v => e.includes(v)));\n      return intersection.length > 0 ? intersection : arrays.reduce((acc, e) => acc.concat(e), []);\n    },\n\n    // For any unknown keywords (e.g., `example`, `format`, `x-readme-ref-name`), we fallback to\n    // using the `title` resolver (which uses the first value found).\n    // https://github.com/mokkabonna/json-schema-merge-allof/blob/ea2e48ee34415022de5a50c236eb4793a943ad11/src/index.js#L292\n    // https://github.com/mokkabonna/json-schema-merge-allof/blob/ea2e48ee34415022de5a50c236eb4793a943ad11/README.md?plain=1#L147\n    defaultResolver: mergeJSONSchemaAllOf.options.resolvers.title,\n  },\n};\n\nexport interface toJSONSchemaOptions {\n  /**\n   * Whether or not to extend descriptions with a list of any present enums.\n   */\n  addEnumsToDescriptions?: boolean;\n\n  /**\n   * Current location within the schema -- this is a JSON pointer.\n   */\n  currentLocation?: string;\n\n  /**\n   * An OpenAPI definition to use for schema `$ref` pointer resolutions.\n   */\n  definition?: OASDocument;\n\n  /**\n   * Object containing a global set of defaults that we should apply to schemas that match it.\n   */\n  globalDefaults?: Record<string, unknown>;\n\n  /**\n   * If you wish to hide properties that are marked as being `readOnly`.\n   */\n  hideReadOnlyProperties?: boolean;\n\n  /**\n   * If you wish to hide properties that are marked as being `writeOnly`.\n   */\n  hideWriteOnlyProperties?: boolean;\n\n  /**\n   * Is this schema the child of a polymorphic `allOf` schema?\n   */\n  isPolymorphicAllOfChild?: boolean;\n\n  /**\n   * Array of parent `default` schemas to utilize when attempting to path together schema defaults.\n   */\n  prevDefaultSchemas?: SchemaObject[];\n\n  /**\n   * Array of parent `example` schemas to utilize when attempting to path together schema examples.\n   */\n  prevExampleSchemas?: SchemaObject[];\n\n  /**\n   * A function that's called anytime a (circular) `$ref` is found.\n   */\n  refLogger?: (ref: string, type: 'discriminator' | 'ref') => void;\n\n  /**\n   * Tracks component `$ref` pointers that were already emitted as bare `{ $ref }` stubs in this\n   * conversion. Used so a later duplicate bare `$ref` to the same component keeps the stub,\n   * while a bare `$ref` that follows an `allOf` merge of the same ref still inlines the expanded\n   * schema.\n   */\n  refsEmittedAsStub?: Set<string>;\n\n  /**\n   * A set of `$ref` pointers that have been seen during JSON Schema generation.\n   */\n  seenRefs?: Set<string>;\n\n  /**\n   * A dictionary of referenced schema names to their compiled JSON Schema objects.\n   */\n  usedSchemas?: Map<string, SchemaObject>;\n}\n\n/**\n * Placeholder value in `usedSchemas` while a schema is being converted (used for circular\n * references).\n */\nconst PENDING_SCHEMA = { __pending: true } as unknown as SchemaObject;\n\nfunction isPendingSchema(s: SchemaObject): boolean {\n  return isObject(s) && '__pending' in s && (s as Record<string, unknown>).__pending === true;\n}\n\nexport function getSchemaVersionString(schema: SchemaObject, api: OASDocument): string {\n  // If we're not on OpenAPI 3.1+ then we should fall back to the default schema version.\n  if (isOpenAPI30(api)) {\n    // This should remain as an HTTP url, not HTTPS.\n    return 'http://json-schema.org/draft-04/schema#';\n  }\n\n  // If the schema indicates the version, prefer that.\n  if (schema.$schema) {\n    return schema.$schema;\n  }\n\n  // If the user defined a global schema version on their OAS document, prefer that.\n  if (api.jsonSchemaDialect) {\n    return api.jsonSchemaDialect;\n  }\n\n  return 'https://json-schema.org/draft/2020-12/schema#';\n}\n\nfunction isPolymorphicSchema(schema: SchemaObject): boolean {\n  return 'allOf' in schema || 'anyOf' in schema || 'oneOf' in schema;\n}\n\nfunction formatEnumDescription(values: unknown[]): string {\n  return values\n    .filter(value => value !== undefined && (typeof value !== 'string' || value.trim() !== ''))\n    .map(value => `\\`${value}\\``)\n    .join(' ');\n}\n\nfunction withoutGeneratedEnumDescription(schema: SchemaObject): SchemaObject {\n  if (!Array.isArray(schema.enum) || typeof schema.description !== 'string') {\n    return schema;\n  }\n\n  const enumDescription = formatEnumDescription(schema.enum);\n  if (!enumDescription) {\n    return schema;\n  }\n\n  const paragraphs = schema.description.split(/\\n\\n+/);\n  if (!paragraphs.includes(enumDescription)) {\n    return schema;\n  }\n\n  const description = paragraphs.filter(paragraph => paragraph !== enumDescription).join('\\n\\n');\n  const updatedSchema = { ...schema };\n\n  if (description) {\n    updatedSchema.description = description;\n  } else {\n    delete updatedSchema.description;\n  }\n\n  return updatedSchema;\n}\n\n/**\n * Decides if a single `oneOf` / `anyOf` entry should be merged with the parent schemas' sibling\n * `items` by wrapping both in `allOf` and running them through `toJSONSchema` (which merges\n * `allOf` schemas together).\n *\n * The reason this exists is that end-users sometimes place `items` next to `oneOf` and `anyOf`\n * declarations within the same schema and we want to attach those element constraints to each\n * polymorphic branch. This however only works when the branch and `items` can be merged, otherwise\n * `json-schema-merge-allof` will throw an exception (eg. you can't merge `object` and `array`\n * together), resulting in us returning an invalid schema of `{}`.\n *\n */\nfunction shouldFoldParentItemsIntoPolymorphBranch(item: unknown): boolean {\n  if (!isObject(item)) return false;\n  if (isRef(item)) return true;\n\n  const branch: SchemaObject = item;\n  if (!('type' in branch) || branch.type === undefined) return true;\n  if (!hasSchemaType(branch, 'array')) return false;\n\n  return !('items' in branch) || branch.items === undefined;\n}\n\n/**\n * Determine if a polymorphic schema is comprised of empty schemas.\n *\n */\nfunction isEmptyPolymorphicSchema(list: unknown): boolean {\n  if (!Array.isArray(list)) return false;\n  if (!list.length) return true;\n\n  return list.every(branch => {\n    if (branch === null || branch === undefined) return true;\n    if (typeof branch !== 'object' || Array.isArray(branch)) return false;\n    return Array.isArray(branch) ? !branch.length : !Object.keys(branch as object).length;\n  });\n}\n\n/**\n * Inline any `$ref` pointer into an objects schema so that `json-schema-merge-allof` can merge\n * them together. We need to do this because `json-schema-merge-allof` does not support `$ref`\n * pointer resolution.\n */\nfunction inlinePropertyRefsForMerge(\n  schema: SchemaObject,\n  usedSchemas: Map<string, SchemaObject>,\n  refLogger: NonNullable<toJSONSchemaOptions['refLogger']>,\n  conflictPaths?: Set<string>,\n  currentPath?: string,\n): SchemaObject {\n  const out = structuredClone(schema);\n  if (!('properties' in out) || typeof out.properties !== 'object' || out.properties === null) {\n    return out;\n  }\n\n  for (const key of Object.keys(out.properties)) {\n    const path = currentPath ? `${currentPath}.${key}` : key;\n    const val = out.properties[key];\n    if (isRef(val)) {\n      // Do not inline `#/paths/...` refs when we merge `allOf` schemas together, they should\n      // remain untouched so we can preserve them later.\n      if (val.$ref.startsWith('#/paths/')) {\n        refLogger(val.$ref, 'ref');\n        continue;\n      }\n\n      const resolved = usedSchemas.get(val.$ref);\n      if (resolved !== undefined && !isPendingSchema(resolved)) {\n        const isConflictPath = conflictPaths?.has(path) ?? false;\n\n        // At conflict paths, recurse so nested `$ref`s in the chain are inlined too\n        // otherwise the merge sees a surviving `$ref` and drops sibling properties.\n        // NOTE: we only recurse down to the first non conflict path and not the full resolution\n        const inlined: SchemaObject = isConflictPath\n          ? inlinePropertyRefsForMerge(structuredClone(resolved), usedSchemas, refLogger, conflictPaths, path)\n          : structuredClone(resolved);\n\n        // Preserve metadata-only siblings (e.g. `description`, `title`) alongside a `$ref` so\n        // they survive `allOf` merging. Validation keywords (`properties`, `items`, `type`, etc.)\n        // are dropped.\n        //\n        // The spec treats `{$ref: \"...\"}` in a schema slot differently across versions:\n        //\n        // - OAS 3.0: it becomes a Reference Object (the Schema Object section says \"a Reference\n        //   Object can be used in its place\"), and Reference Objects forbid siblings. So 3.0\n        //   strips everything.\n        //   https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#schema-object\n        //   https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#reference-object\n        //\n        // - OAS 3.1: it stays a Schema Object with `$ref` as a JSON Schema 2020-12 keyword. Per\n        //   JSON Schema 2020-12 §8.2.3.1, \"$ref\" is an applicator whose \"results are the results\n        //   of the referenced schema\", and the spec explicitly notes that \"other keywords can\n        //   appear alongside of '$ref' in the same schema object\". Those siblings are part of\n        //   the same schema; the spec doesn't say a `$ref` causes them to be dropped.\n        //   https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#schema-object\n        //   https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.3.1\n        //\n        // Since we flatten via spread instead of evaluating siblings alongside the resolved\n        // schema, validation keywords would silently overwrite the referenced schema's\n        // constraints. We drop them to avoid that; annotation-only siblings (and `x-` extensions)\n        // are safe to carry through. This is a deliberate, narrow deviation from the spec.\n\n        const siblings: Record<string, unknown> = {};\n        for (const siblingKey of Object.keys(val)) {\n          if (METADATA_SIBLING_KEYS.has(siblingKey) || siblingKey.startsWith('x-')) {\n            siblings[siblingKey] = (val as Record<string, unknown>)[siblingKey];\n          }\n        }\n        out.properties[key] = {\n          ...inlined,\n          ...siblings,\n        };\n      }\n    } else if (val && typeof val === 'object' && !Array.isArray(val)) {\n      if ('properties' in val) {\n        out.properties[key] = inlinePropertyRefsForMerge(\n          val as SchemaObject,\n          usedSchemas,\n          refLogger,\n          conflictPaths,\n          path,\n        );\n      }\n\n      // Inline allOf-path refs inside oneOf/anyOf to prevent synthetic allOf scaffolding.\n      inlineAllOfRefsDeep((out.properties[key] ?? val) as SchemaObject, usedSchemas);\n    }\n  }\n\n  return out;\n}\n\n/**\n * Finds property paths that appear in two or more `allOf` branches. These are the paths where a\n * surviving `$ref` would cause `json-schema-merge-allof` to drop sibling properties, so callers\n * use this set to know where to deep-resolve refs before merging.\n *\n * usedSchemas isnt actually a must here. the walk does use that map for $ref resolution, but missing\n * entries or a completely empty map will not cause any errors, it just wont find all the conflict paths.\n * however, in theory, usedSchemas should already contain all the possible $refs since that should\n * be resolved and populated by toJSONSchema, the only caller of this function\n */\nfunction collectConflictPaths(allOfBranches: SchemaObject[], usedSchemas: Map<string, SchemaObject>): Set<string> {\n  // Maps each property path to the number of branches that reach it.\n  const pathBranchCount = new Map<string, number>();\n\n  // Reset between branches.\n  const pathsSeenInThisBranch = new Set<string>();\n  const refsCurrentlyResolving = new Set<string>();\n\n  function recordPath(path: string): void {\n    if (pathsSeenInThisBranch.has(path)) return;\n    pathsSeenInThisBranch.add(path);\n    pathBranchCount.set(path, (pathBranchCount.get(path) ?? 0) + 1);\n  }\n\n  function walk(schema: unknown, path?: string): void {\n    if (!isObject(schema)) return;\n\n    // Resolve `$ref`s and keep walking from the resolved schema. If we re-enter a ref we're\n    // already resolving, that's a circular reference. bail\n    if (typeof schema.$ref === 'string') {\n      const ref = schema.$ref;\n      const resolved = usedSchemas.get(ref);\n\n      // bail out if we see a ref we're already resolving, or if the ref is not resolved or is pending\n      // or even if the resolved schema doesnt exists in useSchemas\n      if (refsCurrentlyResolving.has(ref) || !resolved || isPendingSchema(resolved)) return;\n\n      refsCurrentlyResolving.add(ref);\n      walk(resolved, path);\n      refsCurrentlyResolving.delete(ref);\n      return;\n    }\n\n    if (!isObject(schema.properties)) return;\n    for (const [propertyName, childSchema] of Object.entries(schema.properties)) {\n      const childPath = path ? `${path}.${propertyName}` : propertyName;\n      recordPath(childPath);\n      walk(childSchema, childPath);\n    }\n  }\n\n  for (const branch of allOfBranches) {\n    pathsSeenInThisBranch.clear();\n    refsCurrentlyResolving.clear();\n    walk(branch);\n  }\n\n  const conflictPaths = new Set<string>();\n  for (const [path, branchCount] of pathBranchCount) {\n    if (branchCount > 1) conflictPaths.add(path);\n  }\n  return conflictPaths;\n}\n\n/**\n * Some OAS specs use `$ref` pointers that path through `allOf`, e.g.\n * `#/components/schemas/Foo/allOf/1/properties/bar`. After `toJSONSchema` merges the `allOf` flat,\n * these paths become stale, the `allOf` no longer exists in the output. If left as stubs,\n * `mergeReferencedSchemasIntoRoot` recreates a synthetic `allOf` to make them resolvable, which\n * causes downstream consumers to re-merge it and duplicate `oneOf`/`anyOf` entries.\n *\n * This function walks `oneOf`/`anyOf` options and their nested `properties` to find and inline\n * these stale refs. Only refs containing `/allOf/` are replaced and regular component refs are\n * left as stubs for render-time resolution.\n */\nfunction inlineAllOfRefsDeep(schema: SchemaObject, usedSchemas: Map<string, SchemaObject>): void {\n  const allOfKey = '/allOf';\n\n  for (const keyword of ['oneOf', 'anyOf'] as const) {\n    if (!Array.isArray(schema[keyword])) continue;\n    for (let i = 0; i < schema[keyword].length; i++) {\n      const option = schema[keyword][i] as SchemaObject | undefined;\n      if (!option || typeof option !== 'object') continue;\n      if (isRef(option) && option.$ref.includes(allOfKey)) {\n        const resolved = usedSchemas.get(option.$ref);\n        if (resolved !== undefined && !isPendingSchema(resolved)) {\n          schema[keyword][i] = structuredClone(resolved);\n        }\n      } else if (!isRef(option)) {\n        inlineAllOfRefsDeep(option, usedSchemas);\n      }\n    }\n  }\n\n  // We cant rely on `inlinePropertyRefsForMerge` here because it inlines ALL refs, we only\n  // want to inline refs through `/allOf/` paths, leaving component refs as stubs.\n  if ('properties' in schema && typeof schema.properties === 'object' && schema.properties !== null) {\n    for (const key of Object.keys(schema.properties)) {\n      const val = schema.properties[key];\n      if (isRef(val) && val.$ref.includes(allOfKey)) {\n        const resolved = usedSchemas.get(val.$ref);\n        if (resolved !== undefined && !isPendingSchema(resolved)) {\n          schema.properties[key] = structuredClone(resolved);\n        }\n      } else if (val && typeof val === 'object' && !Array.isArray(val) && !isRef(val)) {\n        inlineAllOfRefsDeep(val as SchemaObject, usedSchemas);\n      }\n    }\n  }\n\n  // refs through `allOf/` in `items` and `additionalProperties` are resolved via the depth-sorted\n  // scaffold in `mergeReferencedSchemasIntoRoot` (refs.ts)\n}\n\n/**\n * Resolve and convert a `$ref` schema, caching the converted result in `usedSchemas`.\n *\n * This helper always attempts to dereference and convert the target schema while guarding against\n * circular/invalid refs with `PENDING_SCHEMA`. The `returnMode` controls whether the caller gets\n * back the original `$ref` pointer or the converted JSON Schema representation.\n */\nfunction resolveAndCacheRefSchema({\n  schema,\n  definition,\n  usedSchemas,\n  seenRefs,\n  conversionOptions,\n  returnMode,\n  refLogger,\n}: {\n  schema: ReferenceObject;\n  definition: OASDocument;\n  usedSchemas: Map<string, SchemaObject>;\n  seenRefs: Set<string>;\n  conversionOptions: toJSONSchemaOptions;\n  returnMode: 'ref' | 'converted';\n  refLogger: NonNullable<toJSONSchemaOptions['refLogger']>;\n}): SchemaObject {\n  const ref = schema.$ref;\n  const refsEmittedAsStub = conversionOptions.refsEmittedAsStub;\n  const existing = usedSchemas.get(ref);\n  if (existing !== undefined && !isPendingSchema(existing)) {\n    if (returnMode === 'converted') {\n      return existing;\n    }\n\n    // If we have already seen this bare `$ref` pointer before, and emitted it as a stub, then we\n    // should do the same again here.\n    if (refsEmittedAsStub?.has(ref)) {\n      return { $ref: ref };\n    }\n\n    // If this existing schema isn't a `$ref` pointer then we should return it as-is.\n    if (!isRef(existing)) {\n      return structuredClone(existing);\n    }\n\n    return { $ref: ref };\n  }\n\n  // If our `$ref` was never resolved away from an in-progress schema then it's either invalid\n  // or a circular reference and we should return it as-is.\n  if (existing !== undefined && isPendingSchema(existing)) {\n    refsEmittedAsStub?.add(ref);\n    return { $ref: ref };\n  }\n\n  usedSchemas.set(ref, PENDING_SCHEMA);\n\n  if (returnMode === 'ref') {\n    // If we want to return the original `$ref` pointer then we should make an attempt to resolve\n    // and lazily dereference it into our `usedSchemas` store.\n    let resolved: SchemaObject;\n    try {\n      const dereferenced = dereferenceRef(schema, definition, seenRefs);\n      if (isRef(dereferenced)) {\n        refLogger(dereferenced.$ref, 'ref');\n\n        let converted: SchemaObject;\n        try {\n          // `jsonpointer` doesn't understand the `#` prefix that `$ref` pointers have so we need\n          // to shave it off.\n          const pointer = ref.startsWith('#') ? decodeURIComponent(ref.substring(1)) : ref;\n          const rawSchema = jsonpointer.get(definition, pointer);\n          if (rawSchema && typeof rawSchema === 'object') {\n            converted = toJSONSchema(structuredClone(rawSchema), { ...conversionOptions, seenRefs });\n          } else {\n            converted = { $ref: ref };\n          }\n        } catch {\n          converted = { $ref: ref };\n        }\n\n        usedSchemas.set(ref, converted);\n        refLogger(ref, 'ref');\n        refsEmittedAsStub?.add(ref);\n        return { $ref: ref };\n      }\n\n      resolved = dereferenced;\n    } catch {\n      refLogger(ref, 'ref');\n      usedSchemas.set(ref, { $ref: ref });\n      refsEmittedAsStub?.add(ref);\n      return { $ref: ref };\n    }\n\n    const converted = toJSONSchema(structuredClone(resolved), { ...conversionOptions, seenRefs });\n    usedSchemas.set(ref, converted);\n    refLogger(ref, 'ref');\n    refsEmittedAsStub?.add(ref);\n    return { $ref: ref };\n  }\n\n  try {\n    // If we want to return the generated and converted JSON Schema object then, if we have a `$ref`\n    // pointer we should make an attempt to resolve and lazily dereference that into our converted\n    // schema. If that fails then we'll return the original schema.\n    const dereferenced = dereferenceRef(schema, definition, seenRefs);\n    if (isRef(dereferenced)) {\n      let converted: SchemaObject;\n      try {\n        // `jsonpointer` doesn't understand the `#` prefix that `$ref` pointers have so\n        // we need to shave it off.\n        const pointer = ref.startsWith('#') ? decodeURIComponent(ref.substring(1)) : ref;\n        const rawSchema = jsonpointer.get(definition, pointer);\n        if (rawSchema && typeof rawSchema === 'object') {\n          converted = toJSONSchema(structuredClone(rawSchema), { ...conversionOptions, seenRefs });\n        } else {\n          converted = { $ref: ref };\n        }\n      } catch {\n        converted = { $ref: ref };\n      }\n\n      usedSchemas.set(ref, converted);\n      return converted;\n    }\n\n    const converted = toJSONSchema(structuredClone(dereferenced), { ...conversionOptions, seenRefs });\n    usedSchemas.set(ref, converted);\n    return converted;\n  } catch {\n    usedSchemas.set(ref, { $ref: ref });\n    return { $ref: ref };\n  }\n}\n\nfunction isRequestBodySchema(schema: unknown): schema is RequestBodyObject {\n  return 'content' in (schema as RequestBodyObject);\n}\n\n/**\n * Given a JSON pointer, a type of property to look for, and an array of schemas do a reverse\n * search through them until we find the JSON pointer, or part of it, within the array.\n *\n * This function will allow you to take a pointer like `/tags/name` and return back `buster` from\n * the following array:\n *\n * ```\n *  [\n *    {\n *      example: {id: 20}\n *    },\n *    {\n *      examples: {\n *        distinctName: {\n *          tags: {name: 'buster'}\n *        }\n *      }\n *    }\n *  ]\n * ```\n *\n * Within each example the most specific pointer is tried first, so `tags.id` picks up the example's\n * own `tags.id` rather than an `id` further up the stack. If the example has nothing at `tags.id`,\n * the trailing segments of the path (`/id`) are tried next, since that's how an example declared on\n * a nested schema reaches its own properties. This fallback behaviour means a property without an\n * example can inadvertently pick up the value of a shallower property that shares its name - which\n * is okay as any example is usually better than no example regardless.\n *\n * @see {@link https://tools.ietf.org/html/rfc6901}\n * @param property Specific type of schema property to look for a value for.\n * @param pointer JSON pointer to search for an example for.\n * @param schemas Array of previous schemas we've found relating to this pointer.\n */\nfunction searchForValueByPropAndPointer(\n  property: 'default' | 'example',\n  pointer: string,\n  schemas: toJSONSchemaOptions['prevDefaultSchemas'] | toJSONSchemaOptions['prevExampleSchemas'] = [],\n) {\n  if (!schemas.length || !pointer.length) {\n    return;\n  }\n\n  const locSplit = pointer.split('/').filter(Boolean).toReversed();\n  const pointers = [];\n\n  let point = '';\n  for (let i = 0; i < locSplit.length; i += 1) {\n    point = `/${locSplit[i]}${point}`;\n    pointers.push(point);\n  }\n\n  let foundValue: any;\n  const rev = [...schemas].toReversed();\n\n  for (let ii = 0; ii < rev.length; ii += 1) {\n    let schema = rev[ii];\n\n    if (property === 'example') {\n      if ('example' in schema) {\n        schema = schema.example;\n      } else {\n        if (!Array.isArray(schema.examples) || !schema.examples.length) {\n          continue;\n        }\n\n        // Prevent us from crashing if `examples` is a completely empty object.\n        schema = [...schema.examples].shift();\n      }\n    } else {\n      schema = schema.default;\n    }\n\n    for (let i = pointers.length - 1; i >= 0; i -= 1) {\n      try {\n        foundValue = jsonpointer.get(schema, pointers[i]);\n      } catch {\n        // If the schema we're looking at is `{obj: null}` and our pointer is `/obj/propertyName`\n        // `jsonpointer` will throw an error. If that happens, we should silently catch and toss it\n        // and return no example.\n      }\n\n      if (foundValue !== undefined) {\n        break;\n      }\n    }\n\n    if (foundValue !== undefined) {\n      break;\n    }\n  }\n\n  return foundValue;\n}\n\n/**\n * Given an OpenAPI-flavored JSON Schema, make an effort to modify it so it's shaped more towards\n * stock JSON Schema.\n *\n * Why do this?\n *\n *  1. OpenAPI 3.0.x supports its own flavor of JSON Schema that isn't fully compatible with most\n *    JSON Schema tooling (like `@readme/oas-form` or `@rjsf/core`).\n *  2. While validating an OpenAPI definition will prevent corrupted or improper schemas from\n *    occuring, we have a lot of legacy schemas in ReadMe that were ingested before we had proper\n *    validation in place, and as a result have some API definitions that will not pass validation\n *    right now. In addition to reshaping OAS-JSON Schema into JSON Schema this library will also\n *    fix these improper schemas: things like `type: object` having `items` instead of `properties`,\n *    or `type: array` missing `items`.\n *  3. To ease the burden of polymorphic handling on our form rendering engine we make an attempt\n *    to merge `allOf` schemas here.\n *  4. Additionally due to OpenAPI 3.0.x not supporting JSON Schema, in order to support the\n *    `example` keyword that OAS supports, we need to do some work in here to remap it into\n *    `examples`. However, since all we care about in respect to examples for usage within\n *    `@readme/oas-form`, we're only retaining primitives. This *slightly* deviates from JSON\n *    Schema in that JSON Schema allows for any schema to be an example, but since\n *    `@readme/oas-form` can only actually **render** primitives, that's what we're retaining.\n *  5. Though OpenAPI 3.1 does support full JSON Schema, this library should be able to handle it\n *    without any problems.\n *\n * And why use this over `@openapi-contrib/openapi-schema-to-json-schema`? Fortunately and\n * unfortunately we've got a lot of API definitions in our database that aren't currently valid so\n * we need to have a lot of bespoke handling for odd quirks, typos, and missing declarations that\n * might be present.\n *\n * @todo add support for `schema: false` and `not` cases.\n * @todo tighten up `data` to allow for `SchemaObject | ReferenceObject`\n * @see {@link https://json-schema.org/draft/2019-09/json-schema-validation.html}\n * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#schema-object}\n * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#schema-object}\n * @param data OpenAPI Schema Object to convert to pure JSON Schema.\n */\nexport function toJSONSchema(data: SchemaObject | boolean, opts?: toJSONSchemaOptions): SchemaObject {\n  let schema = data === true ? {} : { ...data };\n  const schemaAdditionalProperties = isSchema(schema) ? schema.additionalProperties : null;\n\n  const {\n    addEnumsToDescriptions,\n    currentLocation,\n    definition,\n    globalDefaults,\n    hideReadOnlyProperties,\n    hideWriteOnlyProperties,\n    isPolymorphicAllOfChild,\n    prevDefaultSchemas = [],\n    prevExampleSchemas = [],\n    refLogger,\n    seenRefs,\n    usedSchemas,\n    refsEmittedAsStub = new Set<string>(),\n  } = {\n    addEnumsToDescriptions: false,\n    currentLocation: '',\n    globalDefaults: {},\n    hideReadOnlyProperties: false,\n    hideWriteOnlyProperties: false,\n    isPolymorphicAllOfChild: false,\n    prevDefaultSchemas: [] as toJSONSchemaOptions['prevDefaultSchemas'],\n    prevExampleSchemas: [] as toJSONSchemaOptions['prevExampleSchemas'],\n    refLogger: () => true,\n    seenRefs: new Set<string>(),\n    usedSchemas: new Map<string, SchemaObject>(),\n    refsEmittedAsStub: new Set<string>(),\n    ...opts,\n  };\n\n  const polyOptions: toJSONSchemaOptions = {\n    addEnumsToDescriptions,\n    currentLocation,\n    definition,\n    globalDefaults,\n    hideReadOnlyProperties,\n    hideWriteOnlyProperties,\n    isPolymorphicAllOfChild: false,\n    prevDefaultSchemas,\n    prevExampleSchemas,\n    refLogger,\n    seenRefs,\n    usedSchemas,\n    refsEmittedAsStub,\n  };\n\n  function convertExamples(obj: SchemaObject): void {\n    if ('example' in obj) {\n      if (isPrimitive(obj.example)) {\n        obj.examples = [obj.example];\n      } else if (Array.isArray(obj.example)) {\n        obj.examples = (obj.example as unknown[]).filter(example => isPrimitive(example));\n        if (!(obj.examples as unknown[]).length) {\n          delete obj.examples;\n        }\n      } else {\n        prevExampleSchemas.push({ example: obj.example });\n      }\n      delete obj.example;\n    } else if ('examples' in obj) {\n      let reshapedExamples = false;\n      if (typeof obj.examples === 'object' && obj.examples !== null && !Array.isArray(obj.examples)) {\n        const examples: unknown[] = [];\n\n        Object.entries(obj.examples as Record<string, unknown>).forEach(([name, example]) => {\n          let currentExample = example as ExampleObject | ReferenceObject;\n          if (name === '$ref') {\n            currentExample = dereferenceRef({ $ref: currentExample } as ReferenceObject, definition, seenRefs);\n            if (!currentExample || isRef(currentExample)) {\n              refLogger(currentExample.$ref, 'ref');\n              return;\n            }\n          }\n\n          if ('value' in currentExample) {\n            if (isPrimitive(currentExample.value)) {\n              examples.push(currentExample.value);\n              reshapedExamples = true;\n            } else if (Array.isArray(currentExample.value) && isPrimitive(currentExample.value[0])) {\n              examples.push(currentExample.value[0]);\n              reshapedExamples = true;\n            } else {\n              prevExampleSchemas.push({ example: currentExample.value });\n            }\n          }\n        });\n\n        if (examples.length) {\n          reshapedExamples = true;\n          obj.examples = examples;\n        }\n      } else if (Array.isArray(obj.examples) && isPrimitive((obj.examples as unknown[])[0])) {\n        reshapedExamples = true;\n      } else if (Array.isArray(obj.examples) && isObject((obj.examples as unknown[])[0])) {\n        prevExampleSchemas.push({ example: (obj.examples as unknown[])[0] });\n      }\n\n      if (!reshapedExamples) {\n        delete obj.examples;\n      }\n    }\n  }\n\n  // If this schema contains a `$ref` make an attempt to resolve and convert it into our\n  // `usedSchemas` store, but still return the `$ref` in output so we preserve reference identity\n  // instead of inlining a duplicate converted schema at this location.\n  if (isRef(schema)) {\n    if (definition && usedSchemas) {\n      const resolved = resolveAndCacheRefSchema({\n        schema,\n        definition,\n        usedSchemas,\n        seenRefs,\n        conversionOptions: polyOptions,\n        returnMode: 'ref',\n        refLogger,\n      });\n\n      // Preserve metadata siblings (e.g. description, summary) alongside `$ref` pointers because\n      // OpenAPI 3.1 allows those to exist as local overrides. The `properties` keyword at the same\n      // level as `$ref` however is invalid in JSON Schema and should be ignored.\n      const { $ref: _$ref, properties: _propertiesWithRef, ...siblings } = schema as Record<string, unknown>;\n      if (Object.keys(siblings).length > 0) {\n        // An `example` sibling (common when a parameter-level `example` is merged onto a `$ref`\n        // schema) never reaches the `isSchema` normalization branch below, so normalize it here.\n        convertExamples(siblings);\n        return { ...resolved, ...siblings };\n      }\n\n      return resolved;\n    }\n\n    refLogger(schema.$ref, 'ref');\n    return schema;\n  }\n\n  // If we don't have a set type, but are dealing with an `anyOf`, `oneOf`, or `allOf`\n  // representation let's run through them and make sure they're good.\n  if (isSchema(schema, isPolymorphicAllOfChild)) {\n    // If this is an `allOf` schema we should make an attempt to merge so as to ease the burden on\n    // the tooling that ingests these schemas.\n    if ('allOf' in schema && Array.isArray(schema.allOf)) {\n      // A `description` alongside `allOf` overrides the desciption resolved\n      // by `json-schema-merge-allof` (last-wins).\n      //\n      // Using allOf + description is a widely adopted workaround for the oas 3.0 limitation\n      // that $ref cannot have sibling properties. Swagger, for example, resolves it exactly this way.\n      const siblingDescription =\n        typeof schema.description === 'string' && schema.description.length > 0 ? schema.description : undefined;\n\n      // `json-schema-merge-allof` does not resolve `$ref` pointers so if this schema has sibling\n      // `properties` whose internal schemas _also_ contain an `allOf` with multiple `$ref`\n      // pointers, merging the parent `allOf` first can drop those pointers. We should instead\n      // convert each individual property schema first.\n      if (\n        'properties' in schema &&\n        schema.properties !== undefined &&\n        typeof schema.properties === 'object' &&\n        schema.properties !== null &&\n        !Array.isArray(schema.properties)\n      ) {\n        const preprocessed: SchemaObject['properties'] = {};\n        for (const prop of Object.keys(schema.properties)) {\n          const val = schema.properties[prop];\n          if (Array.isArray(val) || (typeof val === 'object' && val !== null)) {\n            const converted = toJSONSchema(val as SchemaObject, {\n              ...polyOptions,\n              currentLocation: `${currentLocation}/${encodePointer(prop)}`,\n              prevDefaultSchemas,\n              prevExampleSchemas,\n            });\n\n            // Drop the property entirely when it was non-empty originally but came back empty —\n            // i.e. `hideReadOnlyProperties` / `hideWriteOnlyProperties` filtered it away. Carrying\n            // an empty placeholder past the `allOf` merge causes the later deletion guard to think\n            // the prop was always empty and skip the delete. Also drop a bare `$ref` whose cached\n            // resolution is empty (same reason).\n            if (hideReadOnlyProperties || hideWriteOnlyProperties) {\n              let resolvedRefIsEmpty = false;\n              if (isRef(converted) && usedSchemas) {\n                const cached = usedSchemas.get(converted.$ref);\n                if (cached && !isRef(cached) && !isPendingSchema(cached) && Object.keys(cached).length === 0) {\n                  resolvedRefIsEmpty = true;\n                }\n              }\n              const originallyNonEmpty = Object.keys(val as SchemaObject).length > 0;\n              if (originallyNonEmpty && (!Object.keys(converted).length || resolvedRefIsEmpty)) {\n                continue;\n              }\n            }\n\n            preprocessed[prop] = converted;\n          } else {\n            preprocessed[prop] = val;\n          }\n        }\n        schema = { ...schema, properties: preprocessed } as SchemaObject;\n      }\n\n      // If we have an API definition present then we should attempt to resolve each `$ref` in an\n      // `allOf` before merging them together with `json-schema-merge-allof` so that that has access\n      // to the full and actual schemas.\n      let allOfSchemas = schema.allOf as SchemaObject[];\n      if (definition && usedSchemas) {\n        // When merging multiple `allOf` schemas together `$ref` pointers that are present are\n        // merged away so we shouldn't log them. When an `allOf` has a single item we're just\n        // unwrapping the schema, so `$ref` pointers _do_ appear in the output then we **should**\n        // log those.\n        const allOfOptions: toJSONSchemaOptions =\n          allOfSchemas.length > 1 ? { ...polyOptions, refLogger: () => {} } : polyOptions;\n\n        allOfSchemas = allOfSchemas.map(item => {\n          if (isRef(item)) {\n            // `isRef` is true for any object with a `$ref` key. When other keywords (e.g. `title`,\n            // `properties`) sit alongside `$ref` in an `allOf` branch, which can be common after\n            // `json-schema-merge-allof` merges a polymorphic schema, resolving only the `$ref`\n            // drops those siblings.\n            //\n            // We should always try to merge the converted target with its converted siblings.\n            if (Object.keys(item).length === 1) {\n              return resolveAndCacheRefSchema({\n                schema: item,\n                definition,\n                usedSchemas,\n                seenRefs,\n                conversionOptions: allOfOptions,\n                returnMode: 'converted',\n                refLogger,\n              });\n            }\n\n            const { $ref, ...siblings } = item as SchemaObject & ReferenceObject;\n            const resolved = resolveAndCacheRefSchema({\n              schema: { $ref },\n              definition,\n              usedSchemas,\n              seenRefs,\n              conversionOptions: allOfOptions,\n              returnMode: 'converted',\n              refLogger,\n            });\n\n            // If all we had was a `$ref` schema then we should return whatever it resolved to.\n            if (!Object.keys(siblings).length) {\n              return resolved;\n            }\n\n            const siblingSchema = toJSONSchema(siblings as SchemaObject, allOfOptions);\n            try {\n              return mergeJSONSchemaAllOf(\n                { allOf: [resolved as JSONSchema4, siblingSchema as JSONSchema4] },\n                mergeAllOfSchemasOptions,\n              ) as SchemaObject;\n            } catch {\n              return resolved;\n            }\n          }\n\n          return toJSONSchema(item as SchemaObject, allOfOptions);\n        });\n\n        if (addEnumsToDescriptions) {\n          // Enum values are added to descriptions during response schema conversion. They are\n          // generated display metadata, so they should not participate in `allOf` description\n          // precedence and overwrite an authored description alongside the `allOf`. Remove the\n          // generated paragraph from each converted branch before merging; the final enum handling\n          // below will append it once to the merged schema.\n          allOfSchemas = allOfSchemas.map(withoutGeneratedEnumDescription);\n        }\n\n        // Find paths reached by 2+ branches, then inline each branch with deep recursion at\n        // those conflict paths.\n        const conflictPaths = collectConflictPaths(allOfSchemas, usedSchemas);\n        schema = {\n          ...schema,\n          allOf: allOfSchemas.map(s => inlinePropertyRefsForMerge(s, usedSchemas, refLogger, conflictPaths)),\n        } as SchemaObject;\n      }\n\n      try {\n        schema = mergeJSONSchemaAllOf(schema as JSONSchema, mergeAllOfSchemasOptions) as SchemaObject;\n\n        // Reinstate the schema's own sibling `description` so it always wins over any `description`\n        // merged in from json-schema-merge-allof.\n        if (siblingDescription !== undefined && isObject(schema) && !isRef(schema)) {\n          schema.description = siblingDescription;\n        }\n      } catch {\n        // The merge can throw on irreconcilable conflicts (eg. `properties.foo.type` being `array`\n        // in one branch and `object` in another). Dropping the entire `allOf` here would leave the\n        // schema with no `type` / `properties` at all, and downstream renderers would have nothing\n        // to show. Instead, do a best-effort shallow merge of each branch's `properties` (later\n        // branches win on conflict) and union `required`, so consumers still see most of the shape.\n        const branches = (schema.allOf as SchemaObject[]) ?? [];\n        const { allOf: _allOf, ...rest } = schema as SchemaObject & { allOf?: SchemaObject[] };\n        const fallback: SchemaObject = { ...rest };\n        const mergedProperties: Record<string, SchemaObject> = {\n          ...(fallback as { properties?: Record<string, SchemaObject> }).properties,\n        };\n        const requiredSet = new Set<string>(Array.isArray(fallback.required) ? (fallback.required as string[]) : []);\n        for (const branch of branches) {\n          if (!branch || typeof branch !== 'object' || isRef(branch)) continue;\n          if (fallback.type === undefined && 'type' in branch && branch.type !== undefined) {\n            fallback.type = branch.type;\n          }\n          if (fallback.title === undefined && typeof branch.title === 'string' && branch.title.length > 0) {\n            fallback.title = branch.title;\n          }\n          if (\n            fallback.description === undefined &&\n            typeof branch.description === 'string' &&\n            branch.description.length > 0\n          ) {\n            fallback.description = branch.description;\n          }\n          if (branch.properties && typeof branch.properties === 'object') {\n            for (const [key, value] of Object.entries(branch.properties)) {\n              mergedProperties[key] = value as SchemaObject;\n            }\n          }\n          if (Array.isArray(branch.required)) {\n            for (const required of branch.required) requiredSet.add(required);\n          }\n        }\n        if (Object.keys(mergedProperties).length > 0) {\n          (fallback as { properties?: unknown }).properties = mergedProperties;\n          if (fallback.type === undefined) fallback.type = 'object';\n        }\n        if (requiredSet.size > 0) {\n          (fallback as SchemaObject & { required?: string[] }).required = [...requiredSet];\n        }\n        schema = fallback;\n      }\n\n      // This is a little messy but because `json-schema-merge-allof` doesn't support attaching a\n      // resolver to a deeply nested `$ref` pointer, which we would need to do in order to emit\n      // that a `$ref` is present in this schema, we need to instead scan the resulting schema\n      // for them.\n      collectRefsInSchema(schema).forEach(ref => {\n        refLogger(ref, 'ref');\n      });\n\n      // If after merging the `allOf` this schema still contains a `$ref` then it's circular and\n      // we shouldn't do anything else. Preserve sibling properties alongside the `$ref`.\n      if (isRef(schema)) {\n        refLogger(schema.$ref, 'ref');\n\n        return schema;\n      }\n    }\n\n    (['anyOf', 'oneOf'] as const).forEach((polyType: 'anyOf' | 'oneOf') => {\n      if (polyType in schema && Array.isArray(schema[polyType])) {\n        const discriminatorPropertyName =\n          'discriminator' in schema && schema.discriminator && isObject(schema.discriminator)\n            ? schema.discriminator.propertyName\n            : undefined;\n\n        schema[polyType].forEach((item, idx) => {\n          if (!schema[polyType]?.[idx]) {\n            // We should never hit this because `anyOf` and `oneOf` ara guaranteed by this point to\n            // be arrays but TS isn't smart enough to carry this inferrence down to this block.\n            return;\n          }\n\n          const itemOptions: toJSONSchemaOptions = {\n            ...polyOptions,\n            currentLocation: `${currentLocation}/${idx}`,\n          };\n\n          // When `properties` or `items` are present alongside a polymorphic schema instead of\n          // letting whatever JSON Schema interpreter is handling these constructed schemas we can\n          // guide its hand a bit by manually transforming it into an inferred `allOf` of the\n          // `properties` + the polymorph schema.\n          //\n          // This `allOf` schema will be merged together when fed through `toJSONSchema`.\n          if ('properties' in schema) {\n            schema[polyType][idx] = toJSONSchema(\n              {\n                required: schema.required,\n                allOf: [item, { properties: schema.properties }],\n              } as SchemaObject,\n              itemOptions,\n            );\n          } else if ('items' in schema) {\n            if (shouldFoldParentItemsIntoPolymorphBranch(item)) {\n              schema[polyType][idx] = toJSONSchema(\n                {\n                  allOf: [item, { items: schema.items }],\n                } as SchemaObject,\n                itemOptions,\n              );\n            } else {\n              schema[polyType][idx] = toJSONSchema(item as SchemaObject, itemOptions);\n            }\n          } else {\n            schema[polyType][idx] = toJSONSchema(item as SchemaObject, itemOptions);\n          }\n\n          // Ensure that we don't have any invalid `required` booleans or empty arrays lying around.\n          if ('required' in (schema[polyType][idx] as SchemaObject)) {\n            if (Array.isArray(schema[polyType][idx].required) && schema[polyType][idx].required.length === 0) {\n              delete (schema[polyType][idx] as SchemaObject).required;\n            } else if (\n              isObject(schema[polyType][idx]) &&\n              typeof (schema[polyType][idx] as SchemaObject).required === 'boolean'\n            ) {\n              delete (schema[polyType][idx] as SchemaObject).required;\n            }\n          }\n\n          // When a parent schema has a discriminator and child schemas inherit via allOf, the child\n          // schemas can inherit the parent's discriminator, oneOf, and anyOf. We remove these\n          // from child schemas to avoid nested discriminator UIs where each child incorrectly shows\n          // all other children as options. This keeps the discriminator only at the parent level.\n          if (discriminatorPropertyName) {\n            const childSchema = schema[polyType][idx] as SchemaObject;\n            if (isObject(childSchema)) {\n              if ('discriminator' in childSchema) {\n                delete (childSchema as Record<string, unknown>).discriminator;\n              }\n              if ('oneOf' in childSchema) {\n                delete (childSchema as Record<string, unknown>).oneOf;\n              }\n              if ('anyOf' in childSchema) {\n                delete (childSchema as Record<string, unknown>).anyOf;\n              }\n            }\n\n            // When the child is a `$ref` the actual schema lives in `usedSchemas` so we should\n            // strip these polymorphic keywords there too.\n            if (definition && usedSchemas && isRef(childSchema)) {\n              const resolved = usedSchemas.get(childSchema.$ref);\n              if (resolved && typeof resolved === 'object' && !isPendingSchema(resolved)) {\n                if ('discriminator' in resolved) {\n                  delete (resolved as Record<string, unknown>).discriminator;\n                }\n                if ('oneOf' in resolved) {\n                  delete (resolved as Record<string, unknown>).oneOf;\n                }\n                if ('anyOf' in resolved) {\n                  delete (resolved as Record<string, unknown>).anyOf;\n                }\n\n                // Instead of relying on the `resolved` reference populating back into `usedSchemas`\n                // we should make sure that that schema is refreshed with our new schema.\n                usedSchemas.set(childSchema.$ref, resolved);\n              }\n            }\n          }\n        });\n      }\n    });\n\n    if (schema?.discriminator?.mapping && typeof schema.discriminator.mapping === 'object') {\n      // Discriminator mappings aren't written as traditional `$ref` pointers so in order to log\n      // them to the supplied `refLogger`.\n      const mapping = schema.discriminator.mapping;\n      Object.keys(mapping).forEach(k => {\n        refLogger(mapping[k], 'discriminator');\n      });\n    }\n  }\n\n  // If this schema is malformed for some reason, let's do our best to repair it.\n  if (!('type' in schema) && !isPolymorphicSchema(schema) && !isRequestBodySchema(schema)) {\n    if ('properties' in schema) {\n      schema.type = 'object';\n    } else if ('items' in schema) {\n      schema.type = 'array';\n    } else {\n      // If there's still no `type` on the schema we should leave it alone because we don't have a\n      // great way to know if it's part of a nested schema that should, and couldn't be merged,\n      // into another, or it's just purely malformed.\n      //\n      // Whatever tooling that ingests the generated schema should handle it however it needs to.\n    }\n  }\n\n  if ('type' in schema && schema.type !== undefined) {\n    // `nullable` isn't a thing in JSON Schema but it was in OpenAPI 3.0 so we should retain and\n    // translate it into something that's compatible with JSON Schema.\n    if ('nullable' in schema) {\n      if (schema.nullable) {\n        if (Array.isArray(schema.type)) {\n          schema.type.push('null');\n        } else if (schema.type !== null && schema.type !== 'null') {\n          schema.type = [schema.type, 'null'];\n        }\n      }\n\n      delete schema.nullable;\n    }\n\n    if (schema.type === null) {\n      // `type: null` is possible in JSON Schema but we're translating it to a string version\n      // so we don't need to worry about asserting nullish types in our implementations of this\n      // generated schema.\n      (schema as SchemaObject).type = 'null';\n    } else if (Array.isArray(schema.type)) {\n      // @ts-expect-error -- `null` is not valid in JSON Schema but it can be done in OpenAPI 3.0.\n      if (schema.type.includes(null)) {\n        // @ts-expect-error -- `null` is not valid in JSON Schema but it can be done in OpenAPI 3.0.\n        schema.type[schema.type.indexOf(null)] = 'null';\n      }\n\n      schema.type = Array.from(new Set(schema.type));\n\n      // We don't need `type: [<type>]` when we can just as easily make it `type: <type>`.\n      if (schema.type.length === 1) {\n        schema.type = schema.type.shift();\n      } else if (schema.type.includes('array') || schema.type.includes('boolean') || schema.type.includes('object')) {\n        // If we have a `null` type but there's only two types present then we can remove `null`\n        // as an option and flag the whole schema as `nullable`.\n        const isNullable = schema.type.includes('null');\n\n        if (schema.type.length === 2 && isNullable) {\n          // If this is `array | null` or `object | null` then we don't need to do anything.\n        } else {\n          // If this mixed type has non-primitives then we for convenience of our implementation\n          // we're moving them into a `oneOf`.\n          const nonPrimitives: any[] = [];\n\n          // Because arrays, booleans, and objects are not compatible with any other schem type\n          // other than null we're moving them into an isolated `oneOf`, and as such want to take\n          // with it its specific properties that may be present on our current schema.\n          Object.entries({\n            // https://json-schema.org/understanding-json-schema/reference/array.html\n            array: [\n              'additionalItems',\n              'contains',\n              'items',\n              'maxContains',\n              'maxItems',\n              'minContains',\n              'minItems',\n              'prefixItems',\n              'uniqueItems',\n            ],\n\n            // https://json-schema.org/understanding-json-schema/reference/boolean.html\n            boolean: [\n              // Booleans don't have any boolean-specific properties.\n            ],\n\n            // https://json-schema.org/understanding-json-schema/reference/object.html\n            object: [\n              'additionalProperties',\n              'maxProperties',\n              'minProperties',\n              'nullable',\n              'patternProperties',\n              'properties',\n              'propertyNames',\n              'required',\n            ],\n          } as Record<string, (keyof SchemaObject)[]>).forEach(([typeKey, keywords]) => {\n            if (!schema.type?.includes(typeKey as JSONSchema7TypeName)) {\n              return;\n            }\n\n            const reducedSchema: any = removeUndefinedObjects({\n              type: isNullable ? [typeKey, 'null'] : typeKey,\n\n              allowEmptyValue: (schema as any).allowEmptyValue ?? undefined,\n              deprecated: schema.deprecated ?? undefined,\n              description: schema.description ?? undefined,\n              readOnly: schema.readOnly ?? undefined,\n              title: schema.title ?? undefined,\n              writeOnly: schema.writeOnly ?? undefined,\n            });\n\n            keywords.forEach(keyword => {\n              if (keyword in schema) {\n                reducedSchema[keyword] = schema[keyword];\n                delete schema[keyword];\n              }\n            });\n\n            nonPrimitives.push(reducedSchema);\n          });\n\n          schema.type = schema.type.filter(t => t !== 'array' && t !== 'boolean' && t !== 'object');\n          if (schema.type.length === 1) {\n            schema.type = schema.type.shift();\n          }\n\n          // Because we may have encountered a fully mixed non-primitive type like `array | object`\n          // we only want to retain the existing schema object if we still have types remaining\n          // in it.\n          if (schema.type && schema.type.length > 1) {\n            schema = { oneOf: [schema, ...nonPrimitives] };\n          } else {\n            schema = { oneOf: nonPrimitives };\n          }\n        }\n      }\n    }\n  }\n\n  if (isSchema(schema, isPolymorphicAllOfChild)) {\n    if ('default' in schema && isObject(schema.default)) {\n      prevDefaultSchemas.push({ default: schema.default });\n    }\n\n    // JSON Schema doesn't support OpenAPI-style examples so we need to reshape them a bit.\n    convertExamples(schema as Record<string, unknown>);\n\n    // If we didn't have any immediately defined examples, let's search backwards and see if we can\n    // find one. But as we're only looking for primitive example, only try to search for one if\n    // we're dealing with a primitive schema.\n    if (!hasSchemaType(schema, 'array') && !hasSchemaType(schema, 'object') && !schema.examples) {\n      const foundExample = searchForValueByPropAndPointer('example', currentLocation, prevExampleSchemas);\n      if (foundExample !== undefined) {\n        // We can only really deal with primitives, so only promote those as the found example if\n        // it is.\n        if (isPrimitive(foundExample) || (Array.isArray(foundExample) && isPrimitive(foundExample[0]))) {\n          schema.examples = [foundExample];\n        }\n      }\n    }\n\n    if (hasSchemaType(schema, 'array')) {\n      if ('items' in schema && schema.items !== undefined) {\n        if (\n          !(definition && usedSchemas) &&\n          !Array.isArray(schema.items) &&\n          Object.keys(schema.items).length === 1 &&\n          isRef(schema.items)\n        ) {\n          // When not resolving refs, `items` that is a lone `$ref` is treated as circular; log and leave as-is.\n          refLogger(schema.items.$ref, 'ref');\n        } else if (schema.items !== true) {\n          // Run through the arrays contents and clean them up (including resolving $ref in items when in ref-resolution mode).\n          // Do not pass prevDefaultSchemas: the array's default (e.g. [12, 34, 56]) belongs on the array,\n          // not on items (we must not set default: 12 on items when the default is already on tags).\n          schema.items = toJSONSchema(schema.items as SchemaObject, {\n            ...polyOptions,\n            currentLocation: `${currentLocation}/0`,\n            prevDefaultSchemas: [],\n            prevExampleSchemas,\n          });\n\n          // If we have a non-array, or empty array, `required` entry in our `items` schema then\n          // it's invalid and we should remove it. We only support non-array boolean `required`\n          // properties inside object properties.\n          if ('required' in schema.items) {\n            if (Array.isArray(schema.items.required) && schema.items.required.length === 0) {\n              delete schema.items.required;\n            } else if (isObject(schema.items) && !Array.isArray(schema.items.required)) {\n              delete schema.items.required;\n            }\n          }\n        }\n      } else if ('properties' in schema || 'additionalProperties' in schema) {\n        // This is a fix to handle cases where someone may have typod `items` as `properties` on an\n        // array. Since throwing a complete failure isn't ideal, we can see that they meant for the\n        // type to be `object`, so we can do our best to shape the data into what they were\n        // intending it to be.\n        schema.type = 'object';\n      } else {\n        // This is a fix to handle cases where we have a malformed array with no `items` property\n        // present.\n        (schema as any).items = {};\n      }\n    } else if (hasSchemaType(schema, 'object')) {\n      if ('properties' in schema && schema.properties !== undefined) {\n        Object.keys(schema.properties).forEach(prop => {\n          if (\n            Array.isArray(schema.properties?.[prop]) ||\n            (typeof schema.properties?.[prop] === 'object' && schema.properties?.[prop] !== null)\n          ) {\n            const newPropSchema = toJSONSchema(schema.properties[prop] as SchemaObject, {\n              ...polyOptions,\n              currentLocation: `${currentLocation}/${encodePointer(prop)}`,\n              // Keep parent defaults visible to this child, but isolate mutations that happen while\n              // walking its descendants. Otherwise a default pushed by one sibling can be found by\n              // later siblings with the same nested property name.\n              prevDefaultSchemas: [...prevDefaultSchemas],\n              prevExampleSchemas,\n            });\n\n            // If this property is read or write only then we should fully hide it from its parent schema.\n            let propShouldBeUpdated = true;\n            if (hideReadOnlyProperties || hideWriteOnlyProperties) {\n              // When the property is a bare `$ref` whose resolved schema was filtered away the recursive call\n              // returns the `$ref` pointer rather than `{}`. Look up the cached resolution so we can drop the\n              // property here too.\n              let resolvedRefIsEmpty = false;\n              if (isRef(newPropSchema) && usedSchemas) {\n                const cached = usedSchemas.get(newPropSchema.$ref);\n                if (cached && !isRef(cached) && !isPendingSchema(cached) && Object.keys(cached).length === 0) {\n                  resolvedRefIsEmpty = true;\n                }\n              }\n\n              if (!Object.keys(newPropSchema).length || resolvedRefIsEmpty) {\n                // We should only delete this schema if it wasn't already empty though. We do this\n                // because we (un)fortunately have handling in our API Explorer form system for\n                // schemas that are devoid of any `type` declaration.\n                if (Object.keys(schema.properties[prop]).length > 0) {\n                  delete schema.properties[prop];\n                  propShouldBeUpdated = false;\n                }\n              }\n            }\n\n            if (propShouldBeUpdated) {\n              schema.properties[prop] = newPropSchema;\n\n              /**\n               * JSON Schema does not have any support for `required: <boolean>` but because some\n               * of our users do this, and it does not throw OpenAPI validation errors thanks to\n               * some extremely loose typings around `schema` in the official JSON Schema\n               * definitions that the OAI offers, we're opting to support these users and upgrade\n               * their invalid `required` definitions into ones that our tooling can interpret.\n               *\n               * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/schemas/v3.1/schema.json#L1114-L1121}\n               */\n              if (\n                isObject(newPropSchema) &&\n                'required' in newPropSchema &&\n                typeof newPropSchema.required === 'boolean' &&\n                newPropSchema.required === true\n              ) {\n                if ('required' in schema && Array.isArray(schema.required)) {\n                  schema.required.push(prop);\n                } else {\n                  schema.required = [prop];\n                }\n\n                delete (schema.properties[prop] as SchemaObject).required;\n              }\n            }\n          }\n        });\n\n        // If we want to hide all readOnly or writeOnly properites and it happens to be that this\n        // object was comprised of only those then we shouldn't render this object.\n        if (hideReadOnlyProperties || hideWriteOnlyProperties) {\n          if (!Object.keys(schema.properties).length) {\n            return {};\n          }\n        }\n      }\n\n      if (typeof schemaAdditionalProperties === 'object' && schemaAdditionalProperties !== null) {\n        // If this `additionalProperties` is completely empty and devoid of any sort of schema,\n        // treat it as such. Otherwise let's recurse into it and see if we can sort it out.\n        if (\n          !('type' in schemaAdditionalProperties) &&\n          !('$ref' in schemaAdditionalProperties) &&\n          // We know it will be a schema object because it's dereferenced\n          !isPolymorphicSchema(schemaAdditionalProperties as SchemaObject)\n        ) {\n          schema.additionalProperties = true;\n        } else {\n          // We know it will be a schema object because it's dereferenced\n          schema.additionalProperties = toJSONSchema(schemaAdditionalProperties as SchemaObject, {\n            ...polyOptions,\n            currentLocation,\n            prevDefaultSchemas,\n            prevExampleSchemas,\n          });\n        }\n      }\n\n      // Since neither `properties` and `additionalProperties` are actually required to be present\n      // on an object, since we construct this schema work to build up a form we still need\n      // *something* for the user to enter in for this object so we'll add back in\n      // `additionalProperties` for that.\n      if (!isPolymorphicSchema(schema) && !('properties' in schema) && !('additionalProperties' in schema)) {\n        schema.additionalProperties = true;\n      }\n    }\n  }\n\n  /**\n   * Users can pass in parameter defaults via JWT User Data. We're checking to see if the defaults\n   * being passed in exist on endpoints via jsonpointer\n   *\n   * @see {@link https://docs.readme.com/docs/passing-data-to-jwt}\n   */\n  if (\n    isSchema(schema, isPolymorphicAllOfChild) &&\n    globalDefaults &&\n    Object.keys(globalDefaults).length > 0 &&\n    currentLocation\n  ) {\n    try {\n      const userJwtDefault = jsonpointer.get(globalDefaults, currentLocation);\n      if (userJwtDefault) {\n        schema.default = userJwtDefault;\n      }\n    } catch {\n      // If jsonpointer returns an error, we won't show any defaults for that path.\n    }\n  }\n\n  // Only add a default value if we actually have one.\n  if ('default' in schema && typeof schema.default !== 'undefined') {\n    if (hasSchemaType(schema, 'object')) {\n      // Defaults for `object` and types have been dereferenced into their children schemas already\n      // above so we don't need to preserve this default anymore.\n      delete schema.default;\n    } else if (\n      ('allowEmptyValue' in schema && schema.allowEmptyValue && schema.default === '') ||\n      schema.default !== ''\n    ) {\n      // If we have `allowEmptyValue` present, and the default is actually an empty string, let it\n      // through as it's allowed.\n    } else {\n      // If the default is empty and we don't want to allowEmptyValue, we need to remove the\n      // default.\n      delete schema.default;\n    }\n  } else if (prevDefaultSchemas.length) {\n    const foundDefault = searchForValueByPropAndPointer('default', currentLocation, prevDefaultSchemas);\n\n    // We shouldn't ever set an object default out of the parent lineage tree defaults because\n    // the contents of that object will be set on the schema that they're a part of. Setting\n    // that object as well would result us in duplicating the defaults for that schema in two\n    // places.\n    if (\n      isPrimitive(foundDefault) ||\n      foundDefault === null ||\n      (Array.isArray(foundDefault) && hasSchemaType(schema, 'array'))\n    ) {\n      (schema as SchemaObject).default = foundDefault;\n    }\n  }\n\n  if (isSchema(schema, isPolymorphicAllOfChild) && 'enum' in schema && Array.isArray(schema.enum)) {\n    // Enums should not have duplicated items as those will break AJV validation.\n    // If we ever target ES6 for typescript we can drop this array.from.\n    // https://stackoverflow.com/questions/33464504/using-spread-syntax-and-new-set-with-typescript/56870548\n    schema.enum = Array.from(new Set(schema.enum));\n\n    // If we want to add enums to descriptions (like in the case of response JSON Schema)\n    // generation we need to convert them into a list of Markdown tilda'd strings. We're also\n    // filtering away empty and falsy strings here because adding empty `` blocks to the description\n    // will serve nobody any good.\n    if (addEnumsToDescriptions) {\n      const enums = formatEnumDescription(schema.enum);\n\n      if (enums.length) {\n        const currentDescription =\n          'description' in schema && typeof schema.description === 'string' ? schema.description : '';\n\n        if (!currentDescription) {\n          schema.description = enums;\n        } else {\n          const paragraphs = currentDescription.split(/\\n\\n+/).map(p => p.trim());\n          const enumParagraphCount = paragraphs.filter(p => p === enums).length;\n\n          // After `allOf` merging nested properties are run through `toJSONSchema` again however\n          // enum description additions may already be present from the first pass, we should avoid\n          // duplicating thoes addendums.\n          if (enumParagraphCount > 1) {\n            const withoutEnum = paragraphs.filter(p => p !== enums);\n            schema.description = withoutEnum.length > 0 ? `${withoutEnum.join('\\n\\n')}\\n\\n${enums}` : enums;\n          } else if (paragraphs.some(p => p === enums)) {\n            // noop\n          } else {\n            schema.description = `${currentDescription}\\n\\n${enums}`;\n          }\n        }\n      }\n    }\n  }\n\n  // Clean up any remaining `items` or `properties` schema fragments lying around if there's also\n  // polymorphism present.\n  if ('anyOf' in schema || 'oneOf' in schema) {\n    // If this polymorphic schema is comprised of schemas that were unable to be merged and are now\n    // empty objects then we should wipe them out because they're fully invalid.\n    for (const key of ['anyOf', 'oneOf'] as const) {\n      if (key in schema && isEmptyPolymorphicSchema(schema[key])) {\n        delete schema[key];\n      }\n    }\n\n    if ('anyOf' in schema || 'oneOf' in schema) {\n      if ('properties' in schema) {\n        delete schema.properties;\n      }\n\n      if ('items' in schema) {\n        delete schema.items;\n        if ('type' in schema && schema.type === 'array') {\n          delete schema.type;\n        }\n      }\n    }\n  }\n\n  // Remove unsupported JSON Schema props.\n  for (let i = 0; i < UNSUPPORTED_SCHEMA_PROPS.length; i += 1) {\n    // Using the as here because the purpose is to delete keys we don't expect, so of course the\n    // typing won't work\n    delete (schema as Record<string, unknown>)[UNSUPPORTED_SCHEMA_PROPS[i]];\n  }\n\n  // If we want to hide any `readOnly` or `writeOnly` schemas, and this one is that, then we\n  // shouldn't return anything.\n  if (hideReadOnlyProperties && 'readOnly' in schema && schema.readOnly === true) {\n    return {};\n  } else if (hideWriteOnlyProperties && 'writeOnly' in schema && schema.writeOnly === true) {\n    return {};\n  }\n\n  return schema;\n}\n","import type { toJSONSchemaOptions } from '../../lib/openapi-to-json-schema.js';\nimport type { ExampleObject, OASDocument, ParameterObject, SchemaObject, SchemaWrapper } from '../../types.js';\nimport type { Operation } from '../index.js';\nimport type { OpenAPIV3_1 } from 'openapi-types';\n\nimport { getExtension, PARAMETER_ORDERING } from '../../extensions.js';\nimport { applyDiscriminatorOneOfToUsedSchemas } from '../../lib/build-discriminator-one-of.js';\nimport { cloneObject } from '../../lib/clone-object.js';\nimport { getParameterContentType } from '../../lib/get-parameter-content-type.js';\nimport { isPrimitive } from '../../lib/helpers.js';\nimport { getSchemaVersionString, toJSONSchema } from '../../lib/openapi-to-json-schema.js';\nimport {\n  collectRefsInSchema,\n  dereferenceRef,\n  filterRequiredRefsToReferenced,\n  mergeReferencedSchemasIntoRoot,\n} from '../../lib/refs.js';\nimport { isRef } from '../../types.js';\n\n// `Accept` and `Content-Type` are always reserved: ReadMe computes them from the operation's\n// response media types and request body, so rendering them as editable header params is redundant\n// and can interfere with request body serialization.\nconst RESERVED_HEADER_PARAMETERS = new Set(['accept', 'content-type']);\n\n/**\n * `Authorization` is also reserved by the OpenAPI spec, but unlike `Accept`/`Content-Type` nothing\n * auto-computes it — it's only ever supplied when the operation has a security scheme. So we only\n * treat a custom `Authorization` header param as reserved when the operation actually has security\n * requirements; otherwise stripping it would remove the only affordance to authenticate the\n * request, silently breaking docs that model auth this way (CX-3611).\n */\nfunction isReservedHeaderParameter(param: ParameterObject, hasSecurity: boolean) {\n  if (param.in !== 'header') return false;\n\n  const name = param.name.toLowerCase();\n  if (RESERVED_HEADER_PARAMETERS.has(name)) return true;\n\n  return hasSecurity && name === 'authorization';\n}\n\n/**\n * The order of this object determines how they will be sorted in the compiled JSON Schema\n * representation.\n *\n * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#parameter-object}\n * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object}\n */\nexport const types: Record<keyof OASDocument, string> = {\n  path: 'Path Params',\n  query: 'Query Params',\n  body: 'Body Params',\n  cookie: 'Cookie Params',\n  formData: 'Form Data',\n  header: 'Headers',\n  metadata: 'Metadata', // This a special type reserved for https://npm.im/api\n};\n\nexport interface getParametersAsJSONSchemaOptions {\n  /**\n   * If provided, the request body schema will be derived from this specific content type\n   * rather than the default preferred one (first JSON-like, then first available).\n   */\n  contentType?: string;\n\n  /**\n   * Contains an object of user defined schema defaults.\n   */\n  globalDefaults?: Record<string, unknown>;\n\n  /**\n   * If you wish to hide properties that are marked as being `readOnly`.\n   */\n  hideReadOnlyProperties?: boolean;\n\n  /**\n   * If you wish to hide properties that are marked as being `writeOnly`.\n   */\n  hideWriteOnlyProperties?: boolean;\n\n  /**\n   * If you wish to include discriminator mapping `$ref` components alongside your\n   * `discriminator` in schemas. Defaults to `true`.\n   */\n  includeDiscriminatorMappingRefs?: boolean;\n\n  /**\n   * If you want the output to be two objects: body (contains `body` and `formData` JSON\n   * Schema) and metadata (contains `path`, `query`, `cookie`, and `header`).\n   */\n  mergeIntoBodyAndMetadata?: boolean;\n}\n\nexport function getParametersAsJSONSchema(\n  operation: Operation,\n  api: OASDocument,\n  opts?: getParametersAsJSONSchemaOptions,\n): SchemaWrapper[] | null {\n  const seenRefs = new Set<string>();\n  const refsByGroup = new Map<string, Set<string>>();\n  const usedSchemasByGroup = new Map<string, Map<string, SchemaObject>>();\n\n  function refLoggerForSchemaGroup(group: string) {\n    let set = refsByGroup.get(group);\n    if (!set) {\n      set = new Set();\n      refsByGroup.set(group, set);\n    }\n\n    return set;\n  }\n\n  function usedSchemasForSchemaGroup(group: string) {\n    let map = usedSchemasByGroup.get(group);\n    if (!map) {\n      map = new Map<string, SchemaObject>();\n      usedSchemasByGroup.set(group, map);\n    }\n\n    return map;\n  }\n\n  const baseSchemaOptions: toJSONSchemaOptions = {\n    definition: api,\n    globalDefaults: opts?.globalDefaults,\n    hideReadOnlyProperties: opts?.hideReadOnlyProperties,\n    hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,\n    seenRefs,\n  };\n\n  function transformRequestBody(): SchemaWrapper | null {\n    const requestBody = operation.getRequestBody(opts?.contentType);\n\n    if (!requestBody) return null;\n\n    const { mediaType, mediaTypeObject, description } = requestBody;\n    const type = mediaType === 'application/x-www-form-urlencoded' ? 'formData' : 'body';\n\n    // If this schema is completely empty, don't bother processing it.\n    if (!mediaTypeObject.schema || !Object.keys(mediaTypeObject.schema).length) {\n      return null;\n    }\n\n    const prevExampleSchemas: toJSONSchemaOptions['prevExampleSchemas'] = [];\n    if ('example' in mediaTypeObject) {\n      prevExampleSchemas.push({ example: mediaTypeObject.example });\n    } else if ('examples' in mediaTypeObject) {\n      prevExampleSchemas.push({\n        examples: Object.values(mediaTypeObject.examples || {})\n          .map(ex => {\n            let example = ex;\n            if (!example) return;\n            if (isRef(example)) {\n              example = dereferenceRef(example, operation.api);\n              if (!example || isRef(example)) return;\n            }\n\n            return example.value;\n          })\n          .filter((item): item is ExampleObject => item !== undefined),\n      });\n    }\n\n    // We're cloning the request schema because we've had issues with request schemas that were\n    // dereferenced being processed multiple times because their component is also processed.\n    const requestSchema = cloneObject(mediaTypeObject.schema);\n\n    const cleanedSchema = toJSONSchema(requestSchema, {\n      ...baseSchemaOptions,\n      usedSchemas: usedSchemasForSchemaGroup(type),\n      prevExampleSchemas,\n      refLogger: ref => refLoggerForSchemaGroup(type).add(ref),\n    });\n\n    // If this schema is **still** empty, don't bother returning it.\n    if (!Object.keys(cleanedSchema).length) {\n      return null;\n    }\n\n    return {\n      type,\n      label: types[type],\n      schema: isPrimitive(cleanedSchema)\n        ? cleanedSchema\n        : {\n            ...cleanedSchema,\n            $schema: getSchemaVersionString(cleanedSchema, api),\n          },\n      ...(description ? { description } : {}),\n    };\n  }\n\n  function transformParameters(): SchemaWrapper[] {\n    const operationParams = operation.getParameters();\n    const hasSecurity = operation.getSecurity().length > 0;\n\n    const transformed = Object.keys(types)\n      .map(type => {\n        const required: string[] = [];\n\n        const parameters = operationParams.filter(param => {\n          return param.in === type && !isReservedHeaderParameter(param, hasSecurity);\n        });\n        if (parameters.length === 0) {\n          return null;\n        }\n\n        const properties = parameters.reduce((prev: Record<string, SchemaObject>, current: ParameterObject) => {\n          let schema: SchemaObject = {};\n          if ('schema' in current) {\n            const currentSchema: SchemaObject = current.schema ? cloneObject(current.schema) : {};\n\n            if (current.example) {\n              // `example` can be present outside of the `schema` block so if it's there we should\n              // pull it in so it can be handled and returned if it's valid.\n              currentSchema.example = current.example;\n            } else if (current.examples) {\n              // `examples` isn't actually supported here in OAS 3.0, but we might as well support\n              // it because `examples` is JSON Schema and that's fully supported in OAS 3.1.\n              currentSchema.examples = current.examples as unknown as unknown[];\n            }\n\n            if (current.deprecated) currentSchema.deprecated = current.deprecated;\n\n            const interimSchema = toJSONSchema(currentSchema, {\n              ...baseSchemaOptions,\n              usedSchemas: usedSchemasForSchemaGroup(type),\n              currentLocation: `/${current.name}`,\n              refLogger: ref => refLoggerForSchemaGroup(type).add(ref),\n            });\n\n            schema = isPrimitive(interimSchema) ? interimSchema : { ...interimSchema };\n          } else if ('content' in current && typeof current.content === 'object') {\n            const contentKeys = Object.keys(current.content);\n            if (contentKeys.length) {\n              const contentType = getParameterContentType(contentKeys);\n              if (\n                contentType &&\n                typeof current.content[contentType] === 'object' &&\n                'schema' in current.content[contentType]\n              ) {\n                const currentSchema: SchemaObject = current.content[contentType].schema\n                  ? cloneObject(current.content[contentType].schema)\n                  : {};\n\n                if (current.example) {\n                  // `example` can be present outside of the `schema` block so if it's there we\n                  // should pull it in so it can be handled and returned if it's valid.\n                  currentSchema.example = current.example;\n                } else if (current.examples) {\n                  // `examples` isn't actually supported here in OAS 3.0, but we might as well\n                  // support it because `examples` is JSON Schema and that's fully supported in OAS\n                  // 3.1.\n                  currentSchema.examples = current.examples as unknown as unknown[];\n                }\n\n                if (current.deprecated) currentSchema.deprecated = current.deprecated;\n\n                const interimSchema = toJSONSchema(currentSchema, {\n                  ...baseSchemaOptions,\n                  usedSchemas: usedSchemasForSchemaGroup(type),\n                  currentLocation: `/${current.name}`,\n                  refLogger: ref => refLoggerForSchemaGroup(type).add(ref),\n                });\n\n                schema = isPrimitive(interimSchema) ? interimSchema : { ...interimSchema };\n              }\n            }\n          }\n\n          // Parameter descriptions don't exist in `current.schema` so `constructSchema` will never\n          // have access to it.\n          if (current.description) {\n            if (!isPrimitive(schema)) {\n              schema.description = current.description;\n            }\n          }\n\n          prev[current.name] = schema;\n\n          if (current.required) {\n            required.push(current.name);\n          }\n\n          return prev;\n        }, {});\n\n        const schema: OpenAPIV3_1.SchemaObject = {\n          $schema: getSchemaVersionString({}, api),\n          type: 'object',\n          properties: properties as Record<string, OpenAPIV3_1.SchemaObject>,\n          ...(required.length > 0 ? { required } : {}),\n        };\n\n        return {\n          type,\n          label: types[type],\n          schema,\n        };\n      })\n      .filter(item => item !== null);\n\n    if (!opts?.mergeIntoBodyAndMetadata) {\n      return transformed;\n    } else if (!transformed.length) {\n      return [];\n    }\n\n    // If we want to merge parameters into a single metadata entry then we need to pull all\n    // available schemas under one roof.\n    return [\n      {\n        type: 'metadata',\n        label: types.metadata,\n        schema: {\n          allOf: transformed.map(r => r.schema),\n        },\n      },\n    ];\n  }\n\n  // If this operation neither has any parameters or a request body then we should return `null`\n  // because there won't be any JSON Schema.\n  if (!operation.hasParameters() && !operation.hasRequestBody()) {\n    return null;\n  }\n\n  // `metadata` is `api` SDK specific, is not a part of the `PARAMETER_ORDERING` extension, and\n  // should always be sorted last. We also define `formData` as `form` in the extension because\n  // we don't want folks to have to deal with casing issues so we need to rewrite it to `formData`.\n  const typeKeys = (getExtension(PARAMETER_ORDERING, api, operation) as string[]).map(k => k.toLowerCase());\n  typeKeys[typeKeys.indexOf('form')] = 'formData';\n  typeKeys.push('metadata');\n\n  const jsonSchema = [transformRequestBody()]\n    .concat(...transformParameters())\n    .filter((item): item is SchemaWrapper => item !== null);\n\n  // For each group include only schemas that are referenced or otherwise used within that groups'\n  // schema. This allows us to avoid having to include schemas or components that are not used,\n  // which would otherwise add to the overall bloat and memory footprint of the generated JSON\n  // Schema object.\n  return jsonSchema\n    .map(group => {\n      if (group.schema && typeof group.schema === 'object') {\n        const usedSchemas = usedSchemasByGroup.get(group.type) ?? new Map<string, SchemaObject>();\n\n        // Apply discriminator `oneOf` arrays to used schemas.\n        applyDiscriminatorOneOfToUsedSchemas(api, usedSchemas, (ref: string) => {\n          if (usedSchemas.has(ref)) {\n            return usedSchemas.get(ref);\n          }\n\n          try {\n            const resolved = dereferenceRef({ $ref: ref }, api, seenRefs);\n            if (isRef(resolved)) return;\n            const converted = toJSONSchema(structuredClone(resolved) as SchemaObject, {\n              ...baseSchemaOptions,\n              usedSchemas,\n              seenRefs,\n            });\n\n            usedSchemas.set(ref, converted);\n            return converted;\n          } catch {\n            // no-op\n          }\n        });\n\n        // Because the `refLogger` does not see every `$ref` that is present in the generated\n        // schema (eg. nested refs inside an `anyOf` branch that was inlined from cache) we need to\n        // collect everything else.\n        const refsInOutput = collectRefsInSchema(group.schema);\n        const refsInGroup = refsByGroup.get(group.type) ?? new Set();\n        const referencedSchemas = filterRequiredRefsToReferenced(\n          new Set([...refsInGroup, ...refsInOutput]),\n          usedSchemas,\n        );\n\n        if (referencedSchemas.size > 0) {\n          mergeReferencedSchemasIntoRoot(group.schema, referencedSchemas);\n        }\n      }\n\n      return group;\n    })\n    .toSorted((a, b) => {\n      return typeKeys.indexOf(a.type) - typeKeys.indexOf(b.type);\n    });\n}\n","import { getParameterContentType } from './lib/get-parameter-content-type.js';\nimport matchesMimeType from './lib/matches-mimetype.js';\nimport { dereferenceRef, dereferenceRefDeep } from './lib/refs.js';\nimport { types as jsonSchemaTypes } from './operation/transformers/get-parameters-as-json-schema.js';\n\nexport const supportedMethods = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'] as const;\n\nexport const SERVER_VARIABLE_REGEX: RegExp = /{([-_a-zA-Z0-9:.[\\]]+)}/g;\n\nexport { getParameterContentType, jsonSchemaTypes, matchesMimeType, dereferenceRef, dereferenceRefDeep };\n"]}

package/dist/{chunk-IV2FDFXA.js → chunk-PZR3GKKO.js}

@@ -3,12 +3,13 @@ import {
 } from "./chunk-QTPMJRIE.js";
 import {
   Operation
-} from "./chunk-7LQKUYC7.js";
+} from "./chunk-5745XRSJ.js";
 import {
   decodePointer,
   encodePointer,
+  findDiscriminatorChildren,
   supportedMethods
-} from "./chunk-A7BAE2SN.js";
+} from "./chunk-3X7ZLPYE.js";
 import {
   isOpenAPI31,
   isRef
@@ -102,6 +103,8 @@ var OpenAPITransformer = class {
    * retaining them would result in an invalid OpenAPI definition.
    */
   $refs = /* @__PURE__ */ new Set();
+  /** Inheritance dependencies discovered by the same helper used for JSON Schema generation. */
+  discriminatorChildrenByParentRef = /* @__PURE__ */ new Map();
   /**
    * A collection of OpenAPI tags that are used within the transformed API definition.
    */
@@ -153,6 +156,16 @@ var OpenAPITransformer = class {
   constructor(definition, options) {
     this.definition = structuredClone(definition);
     this.mode = options.mode;
+    const { children, refs } = findDiscriminatorChildren(this.definition);
+    children.forEach((childNames, parentName) => {
+      const parentRef = refs.get(parentName);
+      if (parentRef) {
+        this.discriminatorChildrenByParentRef.set(
+          parentRef,
+          childNames.flatMap((name) => refs.get(name) ?? [])
+        );
+      }
+    });
   }
   /**
    * Select an OpenAPI tag. Operations with this tag are retained when reducing and removed when
@@ -298,7 +311,9 @@ var OpenAPITransformer = class {
     if ($refSchema === void 0) {
       return;
     }
-    this.queryForRefPointers($refSchema).forEach(({ value: currRef }) => {
+    const referencedValues = this.queryForRefPointers($refSchema).map(({ value }) => value);
+    referencedValues.push(...this.discriminatorChildrenByParentRef.get($ref) ?? []);
+    referencedValues.forEach((currRef) => {
       const foundRef = this.toRefString(currRef);
       if (!foundRef) {
         return;
@@ -822,4 +837,4 @@ var OpenAPITransformer = class {
 export {
   OpenAPITransformer
 };
-//# sourceMappingURL=chunk-IV2FDFXA.js.map
+//# sourceMappingURL=chunk-PZR3GKKO.js.map

package/dist/chunk-PZR3GKKO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/transformer/index.ts","../src/lib/transformer/operation-selection.ts"],"sourcesContent":["import type {\n  ComponentsObject,\n  HttpMethods,\n  OASDocument,\n  OperationObject,\n  PathItemObject,\n  TagObject,\n} from '../../types.js';\nimport type { OpenAPIV3_1 } from 'openapi-types';\n\nimport jsonPointer from 'jsonpointer';\n\nimport { query } from '../../analyzer/util.js';\nimport { Operation } from '../../operation/index.js';\nimport { isOpenAPI31, isRef } from '../../types.js';\nimport { supportedMethods } from '../../utils.js';\nimport { findDiscriminatorChildren } from '../build-discriminator-one-of.js';\nimport { decodePointer, encodePointer } from '../refs.js';\n\nimport { OperationSelection } from './operation-selection.js';\n\ninterface OpenAPITransformerOptions {\n  /** Whether selected paths, operations, and webhooks should be retained or removed. */\n  mode: 'prune' | 'reduce';\n}\n\n/**\n * Internal engine for selecting operations and transforming an OpenAPI definition down to its\n * reachable paths, webhooks, components, and tags.\n */\nexport class OpenAPITransformer {\n  private definition: OASDocument;\n\n  private readonly mode: 'prune' | 'reduce';\n\n  /**\n   * A collection of `$ref` pointers that are used within our transformed API definition. This is\n   * used to ensure that all referenced schemas are retained in our resulting API definition. Not\n   * retaining them would result in an invalid OpenAPI definition.\n   */\n  private $refs: Set<string> = new Set();\n\n  /** Inheritance dependencies discovered by the same helper used for JSON Schema generation. */\n  private discriminatorChildrenByParentRef = new Map<string, string[]>();\n\n  /**\n   * A collection of OpenAPI tags that are used within the transformed API definition.\n   */\n  private usedTags: Set<string> = new Set();\n\n  /**\n   * A collection of OpenAPI paths and operations that are cross-referenced from any other paths\n   * and operations that we're retaining. This collection is used to ensure that those operations\n   * are retained in our resulting API definition. Not retaining them would result in an invalid\n   * OpenAPI definition.\n   *\n   * A `*` method means the entire Path Item is referenced (e.g. `$ref: '#/paths/~1pets'`).\n   */\n  private retainPathMethods: Set<`${string}|${string}`> = new Set();\n\n  /**\n   * Paths whose Path Item *fields* (parameters, servers, summary, …) are referenced without\n   * targeting a specific operation. The path container must remain even if every HTTP operation is\n   * filtered out.\n   */\n  private retainPathContainers: Set<string> = new Set();\n\n  /**\n   * A collection of OpenAPI webhook names and methods that are cross-referenced from any other\n   * schemas. This collection, like `retainPathMethods`, is used to ensure that those operations are\n   * retained in our resulting API definition. Not retaining them would result in an invalid\n   * OpenAPI definition.\n   *\n   * A `*` method means the entire webhook Path Item is referenced (e.g. `$ref: '#/webhooks/newPet'`).\n   */\n  private retainWebhookMethods: Set<`${string}|${string}`> = new Set();\n\n  /**\n   * Webhooks whose Path Item fields are referenced without targeting a specific operation.\n   */\n  private retainWebhookContainers: Set<string> = new Set();\n\n  /** An array of OpenAPI tags selected for the current transformation. */\n  private tagSelection: string[] = [];\n\n  /** A collection of operation IDs selected for the current transformation. */\n  private operationIdSelection = new Set<string>();\n\n  /** A collection of OpenAPI paths and operations selected for the current transformation. */\n  private pathSelection = new OperationSelection();\n\n  /** A collection of OpenAPI webhooks selected for the current transformation. */\n  private webhookSelection = new OperationSelection();\n\n  private hasTagSelection: boolean = false;\n  private hasOperationIdSelection: boolean = false;\n  private hasPathSelection: boolean = false;\n  private hasWebhookSelection: boolean = false;\n\n  /**\n   * @param definition OpenAPI definition to transform.\n   * @param options Transformation mode.\n   */\n  protected constructor(definition: OASDocument, options: OpenAPITransformerOptions) {\n    this.definition = structuredClone(definition);\n    this.mode = options.mode;\n\n    const { children, refs } = findDiscriminatorChildren(this.definition);\n    children.forEach((childNames, parentName) => {\n      const parentRef = refs.get(parentName);\n      if (parentRef) {\n        this.discriminatorChildrenByParentRef.set(\n          parentRef,\n          childNames.flatMap(name => refs.get(name) ?? []),\n        );\n      }\n    });\n  }\n\n  /**\n   * Select an OpenAPI tag. Operations with this tag are retained when reducing and removed when\n   * pruning. Tag casing does not matter.\n   *\n   * @param tag Tag to select.\n   */\n  protected selectTag(tag: string): void {\n    this.tagSelection.push(tag.toLowerCase());\n  }\n\n  /**\n   * Select an entire OpenAPI path and all operations that it contains. Selected paths are retained\n   * when reducing and removed when pruning. Path casing does not matter.\n   *\n   * @param path Path to select.\n   */\n  protected selectPath(path: string): void {\n    this.pathSelection.addAll(path);\n  }\n\n  /**\n   * Select a single OpenAPI operation. Selected operations are retained when reducing and removed\n   * when pruning. Path and method casing does not matter.\n   *\n   * In reduce mode, selecting an operation after its entire path replaces the all-operation\n   * selection with that operation and any operations selected afterward. Prune mode keeps the\n   * entire path selected.\n   *\n   * @param path Path containing the operation.\n   * @param method HTTP method of the operation to select.\n   */\n  protected selectOperation(path: string, method: string): void {\n    if (this.mode === 'reduce' && this.pathSelection.matchesAll(path)) {\n      this.pathSelection.clear(path);\n    }\n\n    this.pathSelection.addOperation(path, method);\n  }\n\n  /**\n   * Select an OpenAPI operation by its operation ID. IDs are matched exactly and are generated\n   * from the operation path and method when one is not authored in the definition.\n   *\n   * @param operationId Operation ID to select.\n   */\n  protected selectOperationId(operationId: string): void {\n    this.operationIdSelection.add(operationId);\n  }\n\n  /**\n   * Select an OpenAPI webhook or one of its operations. Selected webhooks are retained when\n   * reducing and removed when pruning. Webhook and method casing does not matter.\n   *\n   * @param webhookName Webhook to select.\n   * @param method Optional HTTP method of an individual webhook operation to select.\n   */\n  protected selectWebhook(webhookName: string, method?: string): void {\n    if (!method) {\n      this.webhookSelection.addAll(webhookName);\n      return;\n    }\n\n    if (this.mode === 'reduce' && this.webhookSelection.matchesAll(webhookName)) {\n      this.webhookSelection.clear(webhookName);\n    }\n\n    this.webhookSelection.addOperation(webhookName, method);\n  }\n\n  /** Transform the OpenAPI definition according to the configured mode and selections. */\n  protected transform(): OASDocument {\n    if (!this.definition.openapi) {\n      throw new Error('Sorry, only OpenAPI definitions are supported.');\n    }\n\n    this.hasTagSelection = Boolean(this.tagSelection.length);\n    this.hasOperationIdSelection = this.operationIdSelection.size > 0;\n    this.hasPathSelection = this.pathSelection.hasSelections;\n    this.hasWebhookSelection = this.webhookSelection.hasSelections;\n\n    // Retain any root-level security definitions, regardless if they're used or not on operations\n    // that we're retaining.\n    if ('security' in this.definition) {\n      Object.values(this.definition.security || {}).forEach(sec => {\n        Object.keys(sec).forEach(scheme => {\n          this.retainSecurityScheme(scheme);\n        });\n      });\n    }\n\n    this.walkPaths();\n    this.walkWebhooks();\n\n    // Recursively accumulate any components that are in use.\n    this.$refs.forEach($ref => {\n      this.accumulateUsedRefs(this.definition, this.$refs, $ref);\n    });\n\n    this.$refs.forEach(ref => {\n      this.recordPathRef(ref);\n      this.recordWebhookRef(ref);\n    });\n\n    /**\n     * @fixme Resolve referenced Path Items so their operations can be transformed individually.\n     * Targets of those `$ref`s are already retained (see `retainReferencedPathItem`).\n     */\n    this.transformPaths();\n    this.transformWebhooks();\n\n    // Require at least one path or one webhook in the result.\n    const hasPaths = Boolean(this.definition.paths && Object.keys(this.definition.paths).length);\n    const hasWebhooks = Boolean(\n      'webhooks' in this.definition && this.definition.webhooks && Object.keys(this.definition.webhooks).length,\n    );\n\n    // If we don't have any paths or webhooks left, retain the reducer's no-match error to help catch\n    // invalid selections. An empty definition is valid OpenAPI so we allow it when pruning.\n    if (this.mode === 'reduce' && !hasPaths && !hasWebhooks) {\n      throw new Error(\n        'All paths and webhooks in the API definition were removed. Did you supply the right path, operation, or webhook to reduce by?',\n      );\n    }\n\n    // Remove any unused components.\n    if ('components' in this.definition) {\n      Object.keys(this.definition.components || {}).forEach(componentType => {\n        Object.keys(this.definition.components?.[componentType as keyof ComponentsObject] || {}).forEach(component => {\n          // Authored `$ref`s JSON-Pointer-encode `/` and `~` in the component name\n          // (`foo/bar` → `foo~1bar`). Compare against that encoded form or cleanup\n          // deletes a still-referenced target.\n          const componentPointer = `#/components/${componentType}/${encodePointer(component)}`;\n          const refIsUsed =\n            this.$refs.has(componentPointer) ||\n            Array.from(this.$refs).some(ref => {\n              // Because you can have a `$ref` like `#/components/examples/event-min/value`, which\n              // would be accumulated via our `$refs` query, we want to make sure we account for them.\n              // If we don't look for these then we'll end up removing them from the transformed\n              // definition, resulting in data loss and schema corruption.\n              return ref.startsWith(`${componentPointer}/`);\n            });\n\n          if (!refIsUsed) {\n            delete this.definition.components?.[componentType as keyof ComponentsObject]?.[component];\n          }\n        });\n\n        // If this component group is now empty, delete it.\n        if (!Object.keys(this.definition.components?.[componentType as keyof ComponentsObject] || {}).length) {\n          delete this.definition.components?.[componentType as keyof ComponentsObject];\n        }\n      });\n\n      // If this path no longer has any components, delete it.\n      if (!Object.keys(this.definition.components || {}).length) {\n        delete this.definition.components;\n      }\n    }\n\n    // Remove any unused tags.\n    if ('tags' in this.definition) {\n      this.definition.tags = (this.definition.tags ?? []).filter((tag): tag is TagObject => {\n        return Boolean(tag) && this.usedTags.has(tag.name);\n      });\n\n      if (!this.definition.tags?.length) {\n        delete this.definition.tags;\n      }\n    }\n\n    return this.definition;\n  }\n\n  /**\n   * Recursively process a `$ref` pointer and accumulate any other `$ref` pointers that it or its\n   * children use. This handles circular references by skipping `$ref` pointers we have already seen.\n   * Additionally when a `$ref` points to `#/paths` we record the used path + method so we can\n   * retain cross-operation references within the transformed definition.\n   *\n   * @param schema JSON Schema object to look for and accumulate any `$ref` pointers that it may have.\n   * @param $refs Known set of `$ref` pointers.\n   * @param $ref `$ref` pointer to fetch a schema from out of the supplied schema.\n   */\n  private accumulateUsedRefs(schema: Record<string, unknown>, $refs: Set<string>, $ref: string): void {\n    // Record `$ref` pointers aimed at `#/paths` or `#/webhooks` so we can retain any\n    // cross-operation or Path Item references.\n    this.recordPathRef($ref);\n    this.recordWebhookRef($ref);\n\n    let $refSchema: unknown;\n    if (typeof $ref === 'string') $refSchema = jsonPointer.get(schema, $ref.substring(1));\n    if ($refSchema === undefined) {\n      // If the schema we have wasn't fully dereferenced or bundled for whatever reason and this\n      // `$ref` that we have doesn't exist here we shouldn't try to search for more `$ref` pointers\n      // in a schema that doesn't exist.\n      return;\n    }\n\n    const referencedValues = this.queryForRefPointers($refSchema).map(({ value }) => value);\n    // allOf children point back to their parent, so ordinary forward $ref traversal misses them.\n    referencedValues.push(...(this.discriminatorChildrenByParentRef.get($ref) ?? []));\n\n    referencedValues.forEach(currRef => {\n      // Because it's possible to have a schema property named `$ref` that is not a `$ref` pointer,\n      // which our JSONPath query would pick up as a false positive, we want to exclude that from\n      // `$ref` matching as it's not a reference pointer.\n      const foundRef = this.toRefString(currRef);\n      if (!foundRef) {\n        return;\n      }\n\n      // If we've already processed this `$ref` then don't send us into an infinite loop of processing\n      // circular references.\n      if ($refs.has(foundRef)) {\n        return;\n      }\n\n      $refs.add(foundRef);\n      this.accumulateUsedRefs(schema, $refs, foundRef);\n    });\n  }\n\n  /**\n   * Query a JSON Schema object for any `$ref` pointers using JSONPath and return any pointers that\n   * exist.\n   *\n   * @see {@link https://datatracker.ietf.org/doc/html/rfc9535}\n   * @param schema JSON Schema object to look for any `$ref` pointers within it.\n   */\n  private queryForRefPointers(schema: any) {\n    return query([\"$..['$ref']\"], schema);\n  }\n\n  /**\n   * Normalize a value from a `jsonpath-plus` `$ref` query to a `$ref` pointer because JSONPath\n   * queries may return the property value or the parent.\n   *\n   */\n  private toRefString(value: unknown): string | null {\n    if (typeof value === 'string') {\n      return value;\n    } else if (value && typeof value === 'object' && '$ref' in value && typeof value.$ref === 'string') {\n      return value.$ref;\n    }\n\n    return null;\n  }\n\n  /**\n   * If the given `$ref` points into a path, classify how that path must be retained:\n   *\n   * - `#/paths/~1pets` — the entire Path Item (operations included)\n   * - `#/paths/~1pets/get/...` — a single operation\n   * - `#/paths/~1pets/parameters/...` — a Path Item field, so the container must remain\n   */\n  private parsePathRef(\n    $ref: string,\n  ):\n    | { path: string; retention: 'all' }\n    | { path: string; retention: 'operation'; method: string }\n    | { path: string; retention: 'container' }\n    | null {\n    if (typeof $ref !== 'string' || !$ref.startsWith('#/paths/')) {\n      return null;\n    }\n\n    const match = $ref.match(/^#\\/paths\\/([^/]+)(?:\\/([^/]+))?(?:\\/|$)/);\n    if (!match?.[1]) {\n      return null;\n    }\n\n    const path = decodePointer(match[1]);\n    const segment = match[2];\n    if (!segment) {\n      return { path, retention: 'all' };\n    }\n\n    if (supportedMethods.includes(segment.toLowerCase() as HttpMethods)) {\n      return { path, method: segment, retention: 'operation' };\n    }\n\n    return { path, retention: 'container' };\n  }\n\n  /**\n   * If the given `$ref` points into webhooks, classify how that webhook must be retained. Same\n   * retention rules as {@link parsePathRef}.\n   */\n  private parseWebhookRef(\n    $ref: string,\n  ):\n    | { name: string; retention: 'all' }\n    | { name: string; retention: 'operation'; method: string }\n    | { name: string; retention: 'container' }\n    | null {\n    if (typeof $ref !== 'string' || !$ref.startsWith('#/webhooks/')) {\n      return null;\n    }\n\n    const match = $ref.match(/^#\\/webhooks\\/([^/]+)(?:\\/([^/]+))?(?:\\/|$)/);\n    if (!match?.[1]) {\n      return null;\n    }\n\n    const name = decodePointer(match[1]);\n    const segment = match[2];\n    if (!segment) {\n      return { name, retention: 'all' };\n    }\n\n    if (supportedMethods.includes(segment.toLowerCase() as HttpMethods)) {\n      return { name, method: segment, retention: 'operation' };\n    }\n\n    return { name, retention: 'container' };\n  }\n\n  /**\n   * If a Path Item we must keep is itself a `$ref`, retain that target and walk it for further\n   * `$ref`s. `#/paths/~1foo/get/…` (and the webhook equivalent) do not resolve through a\n   * ref-only `/foo` via JSON Pointer, so without this the component is deleted while `/foo`\n   * remains as a dangling `$ref`.\n   */\n  private retainReferencedPathItem(pathItem: PathItemObject | undefined): void {\n    if (!isRef(pathItem) || this.$refs.has(pathItem.$ref)) {\n      return;\n    }\n\n    this.$refs.add(pathItem.$ref);\n    this.accumulateUsedRefs(this.definition, this.$refs, pathItem.$ref);\n  }\n\n  /**\n   * Record a security scheme so component cleanup keeps it. Scheme names are JSON-Pointer-encoded\n   * so they match the same form used for authored `$ref`s (`foo/bar` → `foo~1bar`).\n   */\n  private retainSecurityScheme(scheme: string): void {\n    this.$refs.add(`#/components/securitySchemes/${encodePointer(scheme)}`);\n  }\n\n  /** Record a `#/paths` `$ref` so the target Path Item or operation is not dropped. */\n  private recordPathRef($ref: string): void {\n    const parsed = this.parsePathRef($ref);\n    if (!parsed) {\n      return;\n    }\n\n    const pathLC = parsed.path.toLowerCase();\n    if (parsed.retention === 'all') {\n      this.retainPathMethods.add(`${pathLC}|*`);\n    } else if (parsed.retention === 'operation') {\n      this.retainPathMethods.add(`${pathLC}|${parsed.method.toLowerCase()}`);\n    } else if (!this.retainPathContainers.has(pathLC)) {\n      // Field-level pointers keep every sibling Path Item field, so walk those fields for\n      // component `$ref`s. Traversing only the pointed-to entry would let component cleanup\n      // delete a sibling's target and leave a dangling pointer.\n      this.retainPathContainers.add(pathLC);\n      this.accumulateContainerFieldRefs(this.findPathItem(parsed.path));\n    }\n\n    this.retainReferencedPathItem(this.findPathItem(parsed.path));\n  }\n\n  /** Record a `#/webhooks` `$ref` so the target webhook Path Item or operation is not dropped. */\n  private recordWebhookRef($ref: string): void {\n    const parsed = this.parseWebhookRef($ref);\n    if (!parsed) {\n      return;\n    }\n\n    const nameLC = parsed.name.toLowerCase();\n    if (parsed.retention === 'all') {\n      this.retainWebhookMethods.add(`${nameLC}|*`);\n    } else if (parsed.retention === 'operation') {\n      this.retainWebhookMethods.add(`${nameLC}|${parsed.method.toLowerCase()}`);\n    } else if (!this.retainWebhookContainers.has(nameLC)) {\n      this.retainWebhookContainers.add(nameLC);\n      this.accumulateContainerFieldRefs(this.findWebhook(parsed.name));\n    }\n\n    this.retainReferencedPathItem(this.findWebhook(parsed.name));\n  }\n\n  /** Look up a Path Item by its path, ignoring key casing. */\n  private findPathItem(path: string): PathItemObject | undefined {\n    const pathLC = path.toLowerCase();\n    const key = Object.keys(this.definition.paths || {}).find(candidate => candidate.toLowerCase() === pathLC);\n    return key ? this.definition.paths?.[key] : undefined;\n  }\n\n  /** Look up a webhook Path Item by name, ignoring key casing. */\n  private findWebhook(name: string): PathItemObject | undefined {\n    if (!isOpenAPI31(this.definition) || !this.definition.webhooks) {\n      return undefined;\n    }\n\n    const nameLC = name.toLowerCase();\n    const key = Object.keys(this.definition.webhooks).find(candidate => candidate.toLowerCase() === nameLC);\n    return key ? (this.definition.webhooks[key] as PathItemObject | undefined) : undefined;\n  }\n\n  /**\n   * Accumulate `$ref` pointers from the Path Item fields we keep when a container is retained\n   * (parameters, servers, summary, … — everything except HTTP operations).\n   */\n  private accumulateContainerFieldRefs(pathItem: PathItemObject | undefined): void {\n    if (!pathItem) {\n      return;\n    }\n\n    if (isRef(pathItem)) {\n      this.$refs.add(pathItem.$ref);\n      this.accumulateUsedRefs(this.definition, this.$refs, pathItem.$ref);\n      return;\n    }\n\n    Object.entries(pathItem).forEach(([key, value]) => {\n      if (supportedMethods.includes(key.toLowerCase() as HttpMethods) || value === undefined) {\n        return;\n      }\n\n      this.queryForRefPointers(value).forEach(({ value: ref }) => {\n        const refStr = this.toRefString(ref);\n        if (!refStr) {\n          return;\n        }\n\n        this.$refs.add(refStr);\n        this.accumulateUsedRefs(this.definition, this.$refs, refStr);\n      });\n    });\n  }\n\n  /** Whether any `$ref` requires this path (or one of its operations) to remain. */\n  private isPathRetainedByRef(pathLC: string): boolean {\n    return (\n      this.retainPathContainers.has(pathLC) ||\n      Array.from(this.retainPathMethods).some(key => key.startsWith(`${pathLC}|`))\n    );\n  }\n\n  /** Whether a `$ref` requires this specific path operation — or the entire Path Item — to remain. */\n  private isPathOperationRetainedByRef(pathLC: string, methodLC: string): boolean {\n    return this.retainPathMethods.has(`${pathLC}|*`) || this.retainPathMethods.has(`${pathLC}|${methodLC}`);\n  }\n\n  /**\n   * Whether the path container must remain after its operations have been filtered. Whole-path\n   * `$ref`s also keep the container (and its operations).\n   */\n  private isPathContainerKept(pathLC: string): boolean {\n    return this.retainPathContainers.has(pathLC) || this.retainPathMethods.has(`${pathLC}|*`);\n  }\n\n  /** Whether any `$ref` requires this webhook (or one of its operations) to remain. */\n  private isWebhookRetainedByRef(nameLC: string): boolean {\n    return (\n      this.retainWebhookContainers.has(nameLC) ||\n      Array.from(this.retainWebhookMethods).some(key => key.startsWith(`${nameLC}|`))\n    );\n  }\n\n  /** Whether a `$ref` requires this specific webhook operation — or the entire webhook — to remain. */\n  private isWebhookOperationRetainedByRef(nameLC: string, methodLC: string): boolean {\n    return this.retainWebhookMethods.has(`${nameLC}|*`) || this.retainWebhookMethods.has(`${nameLC}|${methodLC}`);\n  }\n\n  /**\n   * Whether the webhook container must remain after its operations have been filtered.\n   */\n  private isWebhookContainerKept(nameLC: string): boolean {\n    return this.retainWebhookContainers.has(nameLC) || this.retainWebhookMethods.has(`${nameLC}|*`);\n  }\n\n  /** Determine whether a path or webhook is excluded in the current transformation mode. */\n  private isContainerExcluded(selection: OperationSelection, key: string): boolean {\n    if (this.mode === 'prune') {\n      return selection.matchesAll(key);\n    }\n\n    return !selection.has(key);\n  }\n\n  /**\n   * Determine whether an operation passes the configured filters before cross-operation references\n   * are considered.\n   */\n  private shouldRetainOperation(\n    selection: OperationSelection,\n    key: string,\n    method: string,\n    operation: OperationObject,\n  ): boolean {\n    if (this.mode === 'reduce') {\n      // Reduction filters intersect, so an operation must match every configured filter.\n      if (selection.hasSelections && !selection.matches(key, method)) return false;\n      if (\n        this.hasOperationIdSelection &&\n        !this.operationIdSelection.has(Operation.getOperationId(key, method, operation))\n      ) {\n        return false;\n      }\n      if (this.hasTagSelection && !(operation.tags || []).some(tag => this.tagSelection.includes(tag.toLowerCase()))) {\n        return false;\n      }\n    } else {\n      // Pruning filters are additive, so matching any configured filter removes an operation.\n      if (selection.hasSelections && selection.matches(key, method)) return false;\n      if (\n        this.hasOperationIdSelection &&\n        this.operationIdSelection.has(Operation.getOperationId(key, method, operation))\n      ) {\n        return false;\n      }\n      if (this.hasTagSelection && (operation.tags || []).some(tag => this.tagSelection.includes(tag.toLowerCase()))) {\n        return false;\n      }\n    }\n\n    // No configured filter excluded this operation, so retain it in the transformed definition.\n    return true;\n  }\n\n  /** Determine whether a path item contains at least one HTTP operation. */\n  private hasOperations(pathItem: PathItemObject | undefined): boolean {\n    return Boolean(pathItem && supportedMethods.some(method => method in pathItem));\n  }\n\n  /**\n   * Accumulate any `$ref` pointers that are used by common Path Item parameters.\n   *\n   * @param parameters Common Path Item parameters to inspect for `$ref` pointers.\n   */\n  private accumulateParameterRefs(parameters: PathItemObject['parameters'] | undefined): void {\n    if (!parameters) {\n      return;\n    }\n\n    this.queryForRefPointers(parameters).forEach(({ value: ref }) => {\n      const refStr = this.toRefString(ref);\n      if (!refStr) {\n        return;\n      }\n\n      this.$refs.add(refStr);\n      this.accumulateUsedRefs(this.definition, this.$refs, refStr);\n    });\n  }\n\n  /**\n   * Walk through the `paths` in our OpenAPI definition and determine which operations we want to\n   * retain. Accumulate any `$ref` pointers that they use so their referenced schemas can also be\n   * retained in our resulting API definition.\n   *\n   */\n  private walkPaths(): void {\n    if (!('paths' in this.definition) || !this.definition.paths) {\n      return;\n    }\n\n    Object.keys(this.definition.paths).forEach(path => {\n      // When only webhooks were requested (no path/operation filter), ignore all paths, but don't\n      // delete them yet because a selected webhook may reference one of their operations. We'll\n      // remove any that aren't referenced later.\n      if (this.mode === 'reduce' && this.hasWebhookSelection && !this.hasPathSelection) {\n        return;\n      } else if (this.hasPathSelection && this.isContainerExcluded(this.pathSelection, path)) {\n        return;\n      }\n\n      const pathItem = this.definition.paths?.[path];\n\n      /**\n       * Referenced Path Items that remain in the result are preserved intact rather than partially\n       * transformed. Retain the target and continue walking any local sibling fields so that we\n       * retain their dependencies too.\n       * @fixme Resolve referenced Path Items so their operations can be transformed individually.\n       */\n      if (isRef(pathItem)) {\n        this.$refs.add(pathItem.$ref);\n        this.accumulateUsedRefs(this.definition, this.$refs, pathItem.$ref);\n      }\n\n      // If this Path Item has no operations then it will remain in our resulting API definition,\n      // so we need to retain any components referenced by its common parameters.\n      if (!this.hasOperations(pathItem)) {\n        this.accumulateParameterRefs(pathItem?.parameters);\n      }\n\n      Object.keys(pathItem || {}).forEach(method => {\n        // Only process operations and retain any common path-level common properties like\n        // `parameters`, `servers`, `summary`, etc.\n        if (method === 'parameters' || !supportedMethods.includes(method.toLowerCase() as HttpMethods)) {\n          return;\n        }\n\n        const operation = this.definition.paths?.[path]?.[method as HttpMethods] as OperationObject;\n        if (!operation) {\n          throw new Error(`Operation \\`${method} ${path}\\` not found`);\n        }\n\n        // If this operation isn't part of our resulting API definition then ignore it. We'll\n        // remove it later.\n        if (!this.shouldRetainOperation(this.pathSelection, path, method, operation)) {\n          return;\n        }\n\n        (operation.tags || []).forEach((tag: string) => {\n          this.usedTags.add(tag);\n        });\n\n        // Skipped by the `method === 'parameters'` guard above; accumulate here so refs are only\n        // retained when at least one operation on this path passes all filters.\n        this.accumulateParameterRefs(pathItem?.parameters);\n\n        this.queryForRefPointers(operation).forEach(({ value: ref }) => {\n          const refStr = this.toRefString(ref);\n          if (!refStr) {\n            return;\n          }\n\n          this.$refs.add(refStr);\n\n          // Re-run through any `$ref` pointers that we found within this operation and search for\n          // any `$ref` pointers that they also may be using. This also records `#/paths` and\n          // `#/webhooks` targets so they are retained.\n          this.accumulateUsedRefs(this.definition, this.$refs, refStr);\n        });\n\n        Object.values(operation.security || {}).forEach(sec => {\n          Object.keys(sec).forEach(scheme => {\n            this.retainSecurityScheme(scheme);\n          });\n        });\n      });\n    });\n  }\n\n  /**\n   * Walk through the `webhooks` in our OpenAPI definition and determine which operations we want\n   * to retain. Accumulate any `$ref` pointers that they use so their referenced schemas can also be\n   * retained in our resulting API definition.\n   *\n   */\n  private walkWebhooks() {\n    if (!isOpenAPI31(this.definition)) {\n      return;\n    } else if (!('webhooks' in this.definition) || !this.definition.webhooks) {\n      return;\n    }\n\n    const definition = this.definition satisfies OpenAPIV3_1.Document;\n\n    Object.keys(definition.webhooks || {}).forEach(webhookName => {\n      if (this.hasWebhookSelection && this.isContainerExcluded(this.webhookSelection, webhookName)) {\n        return;\n      }\n\n      const webhook: PathItemObject | undefined = definition.webhooks?.[webhookName];\n      if (!webhook || typeof webhook !== 'object') {\n        return;\n      }\n\n      /**\n       * Referenced webhook Path Items that remain in the result are preserved intact rather than\n       * partially transformed. Retain the target and continue walking any local sibling fields so\n       * that we retain their dependencies too.\n       * @fixme Resolve referenced Path Items so their operations can be transformed individually.\n       */\n      if (typeof webhook.$ref === 'string') {\n        this.$refs.add(webhook.$ref);\n        this.accumulateUsedRefs(definition, this.$refs, webhook.$ref);\n      }\n\n      // If this webhook has no operations then it will remain in our resulting API definition, so\n      // we need to retain any components referenced by its common parameters.\n      if (!this.hasOperations(webhook)) {\n        this.accumulateParameterRefs(webhook.parameters);\n      }\n\n      Object.keys(webhook).forEach(method => {\n        // Only process operations and retain any common path-level common properties like\n        // `parameters`, `servers`, `summary`, etc.\n        if (method === 'parameters' || !supportedMethods.includes(method.toLowerCase() as HttpMethods)) {\n          return;\n        }\n\n        const operation = webhook[method as HttpMethods] as OperationObject;\n        if (!operation) {\n          throw new Error(`Webhook operation \\`${method} ${webhookName}\\` not found`);\n        }\n\n        // If this operation isn't part of our resulting API definition then ignore it. We'll\n        // remove it later.\n        if (!this.shouldRetainOperation(this.webhookSelection, webhookName, method, operation)) {\n          return;\n        }\n\n        (operation.tags || []).forEach((tag: string) => {\n          this.usedTags.add(tag);\n        });\n\n        // Skipped by the `method === 'parameters'` guard above; accumulate here so refs are only\n        // retained when at least one operation on this webhook passes all filters.\n        this.accumulateParameterRefs(webhook.parameters);\n\n        this.queryForRefPointers(operation).forEach(({ value: ref }) => {\n          const refStr = this.toRefString(ref);\n          if (!refStr) {\n            return;\n          }\n\n          this.$refs.add(refStr);\n          this.accumulateUsedRefs(definition, this.$refs, refStr);\n        });\n\n        Object.values(operation.security || {}).forEach(sec => {\n          Object.keys(sec).forEach(scheme => {\n            this.retainSecurityScheme(scheme);\n          });\n        });\n      });\n    });\n  }\n\n  /**\n   * Transform our `paths` object according to the paths and operations that we've selected.\n   */\n  private transformPaths(): void {\n    if (!('paths' in this.definition) || !this.definition.paths) {\n      return;\n    }\n\n    Object.keys(this.definition.paths).forEach(path => {\n      const pathLC = path.toLowerCase();\n      const excludePathItem =\n        (this.hasPathSelection && this.isContainerExcluded(this.pathSelection, path)) ||\n        (this.mode === 'reduce' && this.hasWebhookSelection && !this.hasPathSelection);\n\n      if (this.mode === 'prune' && excludePathItem) {\n        if (this.isPathRetainedByRef(pathLC)) {\n          throw new Error(`Cannot remove path \\`${path}\\` because one of its operations is referenced.`);\n        }\n\n        delete this.definition.paths?.[path];\n        return;\n      }\n\n      const pathItem = this.definition.paths?.[path];\n\n      /**\n       * Referenced Path Items are preserved intact during operation-level filtering. If the whole\n       * Path Item is excluded, remove it unless a surviving operation references it.\n       * @fixme Resolve referenced Path Items so their operations can be transformed individually.\n       */\n      if (isRef(pathItem)) {\n        if (excludePathItem && !this.isPathRetainedByRef(pathLC)) {\n          delete this.definition.paths?.[path];\n        }\n\n        return;\n      }\n\n      let removedOperation = false;\n      Object.keys(pathItem || {}).forEach(method => {\n        const methodLC = method.toLowerCase();\n\n        // Only process operations and retain any common path-level common properties like\n        // `parameters`, `servers`, `summary`, etc.\n        if (method === 'parameters' || !supportedMethods.includes(methodLC as HttpMethods)) {\n          return;\n        }\n\n        const retainedByRef = this.isPathOperationRetainedByRef(pathLC, methodLC);\n\n        const operation = this.definition.paths?.[path]?.[method as HttpMethods];\n        if (!operation) {\n          throw new Error(`Operation \\`${method} ${path}\\` not found`);\n        }\n\n        if (excludePathItem || !this.shouldRetainOperation(this.pathSelection, path, method, operation)) {\n          if (this.mode === 'prune' && retainedByRef) {\n            throw new Error(`Cannot remove operation \\`${method.toUpperCase()} ${path}\\` because it is referenced.`);\n          }\n\n          if (!retainedByRef) {\n            delete this.definition.paths?.[path]?.[method as HttpMethods];\n            removedOperation = true;\n            return;\n          }\n        }\n\n        // This operation remains in the transformed definition, so retain any components\n        // referenced by its common Path Item parameters.\n        this.accumulateParameterRefs(pathItem?.parameters);\n\n        // Accumulate a list of used tags so we can filter out any ones that we don't need later.\n        if ('tags' in operation) {\n          operation.tags?.forEach((tag: string) => {\n            this.usedTags.add(tag);\n          });\n        }\n\n        // Accumulate any used operation-level security schemas that we need to retain.\n        if ('security' in operation) {\n          Object.values(operation.security || {}).forEach(sec => {\n            Object.keys(sec).forEach(scheme => {\n              this.retainSecurityScheme(scheme);\n            });\n          });\n        }\n      });\n\n      // If filtering removed every operation from this path then remove its path-level properties\n      // as well. We leave path items that were authored without operations untouched.\n      if (\n        !this.isPathContainerKept(pathLC) &&\n        (((removedOperation || (this.mode === 'reduce' && excludePathItem)) && !this.hasOperations(pathItem)) ||\n          (this.mode === 'reduce' && !Object.keys(this.definition.paths?.[path] || {}).length))\n      ) {\n        delete this.definition.paths?.[path];\n      }\n    });\n\n    // If we don't have any paths left then retain the reducer's no-match error. An empty Paths\n    // Object is valid OpenAPI so we allow it when pruning.\n    if (!Object.keys(this.definition.paths || {}).length) {\n      if (this.mode === 'reduce' && !(this.definition.webhooks && Object.keys(this.definition.webhooks).length)) {\n        throw new Error(\n          'All paths in the API definition were removed. Did you supply the right path name to reduce by?',\n        );\n      }\n\n      if (this.definition.webhooks && Object.keys(this.definition.webhooks).length) {\n        delete this.definition.paths;\n      }\n    }\n  }\n\n  /**\n   * Transform our `webhooks` object according to the webhooks and operations that we've selected.\n   */\n  private transformWebhooks(): void {\n    if (!isOpenAPI31(this.definition)) {\n      return;\n    } else if (!('webhooks' in this.definition) || !this.definition.webhooks) {\n      return;\n    }\n\n    const definition = this.definition satisfies OpenAPIV3_1.Document;\n\n    Object.keys(definition.webhooks || {}).forEach(webhookName => {\n      const nameLC = webhookName.toLowerCase();\n      const excludeWebhook = this.hasWebhookSelection && this.isContainerExcluded(this.webhookSelection, webhookName);\n\n      if (this.mode === 'prune' && excludeWebhook) {\n        if (this.isWebhookRetainedByRef(nameLC)) {\n          throw new Error(`Cannot remove webhook \\`${webhookName}\\` because one of its operations is referenced.`);\n        }\n\n        delete definition.webhooks?.[webhookName];\n        return;\n      }\n\n      const webhook = definition.webhooks?.[webhookName];\n      if (!webhook || typeof webhook !== 'object') {\n        return;\n      }\n\n      /**\n       * Referenced webhook Path Items are preserved intact during operation-level filtering. If\n       * the whole webhook is excluded, remove it unless a surviving operation references it.\n       * @fixme Resolve referenced Path Items so their operations can be transformed individually.\n       */\n      if (isRef(webhook)) {\n        if (excludeWebhook && !this.isWebhookRetainedByRef(nameLC)) {\n          delete definition.webhooks?.[webhookName];\n        }\n\n        return;\n      }\n\n      let removedOperation = false;\n      Object.keys(webhook).forEach(method => {\n        const methodLC = method.toLowerCase();\n        if (method === 'parameters' || !supportedMethods.includes(methodLC as HttpMethods)) {\n          return;\n        }\n\n        const operation = webhook[method as HttpMethods];\n        if (!operation) {\n          throw new Error(`Webhook operation \\`${method} ${webhookName}\\` not found`);\n        }\n\n        const retainedByRef = this.isWebhookOperationRetainedByRef(nameLC, methodLC);\n        if (excludeWebhook || !this.shouldRetainOperation(this.webhookSelection, webhookName, method, operation)) {\n          if (this.mode === 'prune' && retainedByRef) {\n            throw new Error(\n              `Cannot remove operation \\`${method.toUpperCase()} ${webhookName}\\` because it is referenced.`,\n            );\n          }\n\n          if (!retainedByRef) {\n            delete webhook[method as HttpMethods];\n            removedOperation = true;\n            return;\n          }\n        }\n\n        // This operation remains in the transformed definition, so retain any components\n        // referenced by its common Path Item parameters.\n        this.accumulateParameterRefs(webhook.parameters);\n\n        (operation.tags || []).forEach((tag: string) => {\n          this.usedTags.add(tag);\n        });\n\n        Object.values(operation.security || {}).forEach(sec => {\n          Object.keys(sec).forEach(scheme => {\n            this.retainSecurityScheme(scheme);\n          });\n        });\n      });\n\n      if (\n        !this.isWebhookContainerKept(nameLC) &&\n        (((removedOperation || (this.mode === 'reduce' && excludeWebhook)) && !this.hasOperations(webhook)) ||\n          (this.mode === 'reduce' && !Object.keys(definition.webhooks?.[webhookName] || {}).length))\n      ) {\n        delete definition.webhooks?.[webhookName];\n      }\n    });\n\n    if (definition.webhooks && !Object.keys(definition.webhooks).length) {\n      delete definition.webhooks;\n    }\n  }\n}\n","/**\n * Track selected HTTP operations within OpenAPI paths or webhooks. Container keys and HTTP methods\n * are matched without regard to casing.\n */\nexport class OperationSelection {\n  private selections: Map<string, '*' | Set<string>> = new Map();\n\n  /** Whether any paths or webhooks have been selected. */\n  get hasSelections(): boolean {\n    return this.selections.size > 0;\n  }\n\n  /**\n   * Select every operation within a path or webhook.\n   *\n   * @param key Path or webhook key whose operations should be selected.\n   */\n  addAll(key: string): void {\n    this.selections.set(this.normalize(key), '*');\n  }\n\n  /**\n   * Add an operation to the selection for a path or webhook. If every operation for the key is\n   * already selected, that selection remains unchanged.\n   *\n   * @param key Path or webhook key that contains the operation.\n   * @param method HTTP method of the operation to select.\n   */\n  addOperation(key: string, method: string): void {\n    const normalizedKey = this.normalize(key);\n    const normalizedMethod = this.normalize(method);\n    const selection = this.selections.get(normalizedKey);\n\n    if (selection === '*') {\n      return;\n    }\n\n    if (selection instanceof Set) {\n      selection.add(normalizedMethod);\n      return;\n    }\n\n    this.selections.set(normalizedKey, new Set([normalizedMethod]));\n  }\n\n  /**\n   * Clear every operation selection for a path or webhook.\n   *\n   * @param key Path or webhook key to clear.\n   */\n  clear(key: string): void {\n    this.selections.delete(this.normalize(key));\n  }\n\n  /**\n   * Determine whether a path or webhook has any selected operations.\n   *\n   * @param key Path or webhook key to check.\n   */\n  has(key: string): boolean {\n    return this.selections.has(this.normalize(key));\n  }\n\n  /**\n   * Determine whether every operation within a path or webhook is selected.\n   *\n   * @param key Path or webhook key to check.\n   */\n  matchesAll(key: string): boolean {\n    return this.selections.get(this.normalize(key)) === '*';\n  }\n\n  /**\n   * Determine whether an operation is selected.\n   *\n   * @param key Path or webhook key that contains the operation.\n   * @param method HTTP method of the operation to check.\n   */\n  matches(key: string, method: string): boolean {\n    const selection = this.selections.get(this.normalize(key));\n    return selection === '*' || Boolean(selection?.has(this.normalize(method)));\n  }\n\n  /** Normalize path, webhook, and method casing for comparisons. */\n  private normalize(value: string): string {\n    return value.toLowerCase();\n  }\n}\n"],"mappings":"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","names":[]}