schema-components 1.22.0 → 1.24.0

package/dist/openapi/ApiCallbacks.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrRMV0en.mjs";
+import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
 import { CallbackInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiLinks.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrRMV0en.mjs";
+import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
 import { LinkInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiResponseHeaders.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrRMV0en.mjs";
+import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
 import { HeaderInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiSecurity.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrRMV0en.mjs";
+import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
 import { SecurityRequirement, SecurityScheme } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/components.d.mts

@@ -1,6 +1,6 @@
-import { u as FieldOverride, w as SchemaMeta } from "../types-BrRMV0en.mjs";
-import { r as DiagnosticSink } from "../diagnostics-D0QCYGv0.mjs";
-import { a as InferParameterOverrides, g as UnsafeFields, o as InferRequestBodyFields, s as InferResponseFields } from "../typeInference-DkcUHfaM.mjs";
+import { u as FieldOverride, w as SchemaMeta } from "../types-BTB73MB8.mjs";
+import { r as DiagnosticSink } from "../diagnostics-Cbwak-ZX.mjs";
+import { InferParameterOverrides, InferRequestBodyFields, InferResponseFields } from "../core/typeInference.mjs";
 import { WidgetMap } from "../react/SchemaComponent.mjs";
 import { ReactNode } from "react";
 
@@ -16,29 +16,92 @@ type HttpMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patc
  * Extract the literal path keys from a document type, or the broad
  * `string` fallback when the document is untyped at compile time.
  *
- * The `string extends keyof D["paths"]` guard distinguishes a typed
- * `as const` document (whose `paths` map has literal keys) from a
- * runtime `Record<string, unknown>` document (whose `keyof` collapses
- * to `string`). For the runtime case we surface `string` so callers
- * pass arbitrary path values without losing the existing freedom.
+ * For OpenAPI 3.1 documents the union includes keys from `webhooks`
+ * alongside `paths`, because `<ApiOperation>` / `<ApiRequestBody>` /
+ * `<ApiResponse>` resolve webhook names through the same code path as
+ * paths (see `lookupPathItem` in `openapi/resolve.ts`). Without the
+ * webhook keys, a typed `as const` 3.1 document that declares only
+ * webhooks would reject every `path` prop value at compile time
+ * ("Type 'string' is not assignable to type 'never'") despite working
+ * at runtime.
+ *
+ * When the document declares neither a `paths` nor a `webhooks` map
+ * the union falls back to `string` so untyped/foreign inputs keep
+ * working — the constraint is informational, not gating.
+ *
+ * The `string extends keyof P` guard distinguishes a typed `as const`
+ * document (whose `paths` map has literal keys) from a runtime
+ * `Record<string, unknown>` document (whose `keyof` collapses to
+ * `string`). For the runtime case we surface `string` so callers pass
+ * arbitrary path values without losing the existing freedom.
+ */
+type PathKeysOf<D> = HasPathsOrWebhooks<D> extends true ? PathsKey<D> | WebhooksKey<D> : string;
+/**
+ * `true` when `D` declares either a `paths` or a `webhooks` object,
+ * so the `PathKeysOf` union can be derived from real document keys
+ * instead of falling back to `string`.
  */
-type PathKeysOf<D> = D extends {
+type HasPathsOrWebhooks<D> = D extends {
+  paths: Record<string, unknown>;
+} ? true : D extends {
+  webhooks: Record<string, unknown>;
+} ? true : false;
+/**
+ * Literal `paths` keys, or `never` when the document does not declare
+ * a `paths` object. Runtime documents (whose `keyof` collapses to
+ * `string`) widen to `string` so callers retain prior freedom.
+ */
+type PathsKey<D> = D extends {
   paths: infer P;
-} ? P extends Record<string, unknown> ? string extends keyof P ? string : Extract<keyof P, string> : string : string;
+} ? P extends Record<string, unknown> ? string extends keyof P ? string : Extract<keyof P, string> : never : never;
 /**
- * Extract the methods declared on a specific path item, restricted to
- * the OpenAPI-recognised method set so non-method extension keys
- * (e.g. `summary`, `description`, `parameters`) do not pollute the
- * autocomplete.
+ * Literal `webhooks` keys, or `never` when the document does not
+ * declare a `webhooks` object (OpenAPI 3.1 only). Runtime documents
+ * widen to `string`.
+ */
+type WebhooksKey<D> = D extends {
+  webhooks: infer W;
+} ? W extends Record<string, unknown> ? string extends keyof W ? string : Extract<keyof W, string> : never : never;
+/**
+ * Extract the methods declared on a specific path or webhook item,
+ * restricted to the OpenAPI-recognised method set so non-method
+ * extension keys (e.g. `summary`, `description`, `parameters`) do not
+ * pollute the autocomplete.
  *
  * Runtime documents (typed `Record<string, unknown>`) widen back to
  * `string` so callers retain the freedom to pass arbitrary method
  * strings without surfacing an `HttpMethod` constraint at runtime
- * call sites.
+ * call sites. Untyped documents (`unknown`) also widen to `string` so
+ * consumers with no static doc info can supply extension methods —
+ * the canonical `HttpMethod` set is informational, not gating, when
+ * the document carries no structural information at all.
+ *
+ * When the document declares `paths` or `webhooks` but not the
+ * specific entry `P`, the union falls back to `HttpMethod` so callers
+ * can still target an authored operation that compile-time inference
+ * happens to miss (e.g. behind a deferred conditional type).
  */
-type MethodKeysOf<D, P extends string> = IsRuntimeDoc<D> extends true ? string : D extends {
+type MethodKeysOf<D, P extends string> = IsRuntimeDoc<D> extends true ? string : unknown extends D ? string : HasPathsOrWebhooks<D> extends true ? MethodKeysWithFallback<D, P> : HttpMethod;
+/**
+ * Union of literal methods extracted from `paths[P]` and `webhooks[P]`,
+ * falling back to the canonical `HttpMethod` set when neither map
+ * declares the requested entry.
+ */
+type MethodKeysWithFallback<D, P extends string> = [MethodKeysFromPaths<D, P> | MethodKeysFromWebhooks<D, P>] extends [never] ? HttpMethod : MethodKeysFromPaths<D, P> | MethodKeysFromWebhooks<D, P>;
+/**
+ * Methods declared on `paths[P]`, restricted to `HttpMethod`.
+ * Returns `never` when the document has no matching path entry.
+ */
+type MethodKeysFromPaths<D, P extends string> = D extends {
   paths: infer Paths;
-} ? Paths extends Record<string, unknown> ? P extends keyof Paths ? Extract<keyof Paths[P], HttpMethod> : HttpMethod : HttpMethod : HttpMethod;
+} ? Paths extends Record<string, unknown> ? P extends keyof Paths ? Extract<keyof Paths[P], HttpMethod> : never : never : never;
+/**
+ * Methods declared on `webhooks[P]`, restricted to `HttpMethod`.
+ * Returns `never` when the document has no matching webhook entry.
+ */
+type MethodKeysFromWebhooks<D, P extends string> = D extends {
+  webhooks: infer Webhooks;
+} ? Webhooks extends Record<string, unknown> ? P extends keyof Webhooks ? Extract<keyof Webhooks[P], HttpMethod> : never : never : never;
 /**
  * True for the runtime-document sentinel — a `Record<string, unknown>`
  * (or wider) where `keyof` collapses to `string`. Used to drop
@@ -46,40 +109,52 @@ type MethodKeysOf<D, P extends string> = IsRuntimeDoc<D> extends true ? string :
  * freedom to pass arbitrary path/method/status values.
  */
 type IsRuntimeDoc<D> = D extends Record<string, unknown> ? string extends keyof D ? true : false : false;
+/**
+ * Generic "operation under a given map" extractor used by every
+ * downstream `xxKeysOf` helper. Returns the Operation Object for the
+ * given path-or-webhook name and method, or `never` when no such
+ * entry exists.
+ */
+type OperationAt<Map_, P extends string, M extends string> = Map_ extends Record<string, unknown> ? P extends keyof Map_ ? Map_[P] extends Record<string, unknown> ? M extends keyof Map_[P] ? Map_[P][M] : never : never : never : never;
+/**
+ * Locate the Operation Object for `path`/`method` across both `paths`
+ * and `webhooks`. The OpenAPI 3.1 spec assigns webhooks the same
+ * Path Item shape as `paths` entries, so structural inference is
+ * identical once the operation is resolved.
+ */
+type ResolveOperation<D, P extends string, M extends string> = (D extends {
+  paths: infer Paths;
+} ? OperationAt<Paths, P, M> : never) | (D extends {
+  webhooks: infer Webhooks;
+} ? OperationAt<Webhooks, P, M> : never);
 /**
  * Extract the status-code keys declared by an operation's `responses`
  * map. Includes class wildcards (`2XX`, etc.) and the `default`
  * sentinel; runtime documents widen to `string`.
  */
-type StatusKeysOf<D, P extends string, M extends string> = D extends {
-  paths: infer Paths;
-} ? Paths extends Record<string, unknown> ? P extends keyof Paths ? Paths[P] extends Record<string, unknown> ? M extends keyof Paths[P] ? Paths[P][M] extends {
+type StatusKeysOf<D, P extends string, M extends string> = ResolveOperation<D, P, M> extends {
   responses: infer R;
-} ? R extends Record<string, unknown> ? string extends keyof R ? string : Extract<keyof R, string> : string : string : string : string : string : string : string;
+} ? R extends Record<string, unknown> ? string extends keyof R ? string : Extract<keyof R, string> : string : string;
 /**
  * Extract the content-type keys declared on a request body's
  * `content` map for the given path and method. Runtime documents
  * widen to `string`.
  */
-type RequestContentTypesOf<D, P extends string, M extends string> = D extends {
-  paths: infer Paths;
-} ? Paths extends Record<string, unknown> ? P extends keyof Paths ? Paths[P] extends Record<string, unknown> ? M extends keyof Paths[P] ? Paths[P][M] extends {
+type RequestContentTypesOf<D, P extends string, M extends string> = ResolveOperation<D, P, M> extends {
   requestBody: {
     content: infer C;
   };
-} ? C extends Record<string, unknown> ? string extends keyof C ? string : Extract<keyof C, string> : string : string : string : string : string : string : string;
+} ? C extends Record<string, unknown> ? string extends keyof C ? string : Extract<keyof C, string> : string : string;
 /**
  * Extract the content-type keys declared on a response entry's
  * `content` map for the given path, method, and status. Runtime
  * documents widen to `string`.
  */
-type ResponseContentTypesOf<D, P extends string, M extends string, S extends string> = D extends {
-  paths: infer Paths;
-} ? Paths extends Record<string, unknown> ? P extends keyof Paths ? Paths[P] extends Record<string, unknown> ? M extends keyof Paths[P] ? Paths[P][M] extends {
+type ResponseContentTypesOf<D, P extends string, M extends string, S extends string> = ResolveOperation<D, P, M> extends {
   responses: infer R;
 } ? R extends Record<string, unknown> ? S extends keyof R ? R[S] extends {
   content: infer C;
-} ? C extends Record<string, unknown> ? string extends keyof C ? string : Extract<keyof C, string> : string : string : string : string : string : string : string : string : string : string;
+} ? C extends Record<string, unknown> ? string extends keyof C ? string : Extract<keyof C, string> : string : string : string : string : string;
 /**
  * Diagnostics props accepted by every top-level OpenAPI component.
  *
@@ -93,7 +168,7 @@ interface ApiDiagnosticsProps {
   onDiagnostic?: DiagnosticSink;
   strict?: boolean;
 }
-interface ApiOperationProps<Doc = unknown, Path extends PathKeysOf<Doc> = PathKeysOf<Doc>, Method extends MethodKeysOf<Doc, Path> = MethodKeysOf<Doc, Path>> extends ApiDiagnosticsProps {
+interface ApiOperationProps<Doc = unknown, Path extends PathKeysOf<Doc> = PathKeysOf<Doc>, Method extends MethodKeysOf<Doc, Path> = MethodKeysOf<Doc, Path>, ContentType extends RequestContentTypesOf<Doc, Path, Method> = RequestContentTypesOf<Doc, Path, Method>> extends ApiDiagnosticsProps {
   schema: Doc;
   path: Path;
   method: Method;
@@ -101,16 +176,20 @@ interface ApiOperationProps<Doc = unknown, Path extends PathKeysOf<Doc> = PathKe
   onRequestBodyChange?: (value: unknown) => void;
   responseValue?: unknown;
   meta?: SchemaMeta;
-  requestBodyFields?: Doc extends Record<string, unknown> ? InferRequestBodyFields<Doc, Path & string, Method & string> : Record<string, FieldOverride>;
-  /** Escape hatch for recursive schemas where type-level inference fails.
-   * Typed as Record<string, FieldOverride> — use when the schema contains
-   * deeply nested $ref chains.
+  /**
+   * Media type whose request body schema drives `requestBodyFields`
+   * inference. Defaults to the union of declared content types so
+   * callers can omit it; supply explicitly to narrow inference to a
+   * specific media type. Mirrors {@link ApiRequestBodyProps.contentType}
+   * so `<ApiOperation>` can target non-JSON request bodies with the
+   * same precision as `<ApiRequestBody>`.
    */
-  unsafeFields?: UnsafeFields;
+  requestBodyContentType?: ContentType;
+  requestBodyFields?: Doc extends Record<string, unknown> ? InferRequestBodyFields<Doc, Path & string, Method & string, ContentType & string> : Record<string, FieldOverride>;
   /** Instance-scoped widgets. */
   widgets?: WidgetMap;
 }
-declare function ApiOperation<Doc = unknown, Path extends PathKeysOf<Doc> = PathKeysOf<Doc>, Method extends MethodKeysOf<Doc, Path> = MethodKeysOf<Doc, Path>>({
+declare function ApiOperation<Doc = unknown, Path extends PathKeysOf<Doc> = PathKeysOf<Doc>, Method extends MethodKeysOf<Doc, Path> = MethodKeysOf<Doc, Path>, ContentType extends RequestContentTypesOf<Doc, Path, Method> = RequestContentTypesOf<Doc, Path, Method>>({
   schema: doc,
   path,
   method,
@@ -122,7 +201,7 @@ declare function ApiOperation<Doc = unknown, Path extends PathKeysOf<Doc> = Path
   widgets,
   onDiagnostic,
   strict
-}: ApiOperationProps<Doc, Path, Method>): ReactNode;
+}: ApiOperationProps<Doc, Path, Method, ContentType>): ReactNode;
 interface ApiParametersProps<Doc = unknown, Path extends PathKeysOf<Doc> = PathKeysOf<Doc>, Method extends MethodKeysOf<Doc, Path> = MethodKeysOf<Doc, Path>> extends ApiDiagnosticsProps {
   schema: Doc;
   path: Path;

package/dist/openapi/components.mjs

@@ -1,5 +1,6 @@
 import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
 import { emitDiagnostic } from "../core/diagnostics.mjs";
+import { extractRootMetaFromJson } from "../core/adapter.mjs";
 import { walk } from "../core/walker.mjs";
 import { ApiCallbacks } from "./ApiCallbacks.mjs";
 import { ApiLinks } from "./ApiLinks.mjs";
@@ -53,7 +54,7 @@ function resolveRootDoc(doc, diagnostics) {
 function noop() {}
 function renderSchema(schema, rootDocument, options) {
 	if (!isObject(schema)) throw new Error("renderSchema received a non-object schema from the resolver.");
-	const rootMeta = extractRootMetaFromSchema(schema);
+	const rootMeta = extractRootMetaFromJson(schema);
 	const componentMeta = {};
 	if (options.readOnly === true) componentMeta.readOnly = true;
 	if (options.meta !== void 0) for (const [k, v] of Object.entries(options.meta)) componentMeta[k] = v;
@@ -138,7 +139,9 @@ function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBo
 					rootDoc,
 					meta,
 					widgets,
-					idPrefix: joinPath(instancePrefix, "params")
+					idPrefix: joinPath(instancePrefix, "params"),
+					diagnostics,
+					pointerPrefix: operationPointer(path, method)
 				})]
 			}),
 			resolved.requestBody?.schema !== void 0 && /* @__PURE__ */ jsxs("section", {
@@ -196,7 +199,9 @@ function ApiParameters({ schema: doc, path, method, meta, overrides, widgets, on
 			overrides,
 			meta,
 			widgets,
-			idPrefix: instancePrefix
+			idPrefix: instancePrefix,
+			diagnostics,
+			pointerPrefix: operationPointer(path, method)
 		})]
 	});
 }
@@ -331,25 +336,39 @@ function OperationHeader({ operation, pathItem }) {
 		})
 	] });
 }
-function ParameterList({ parameters, rootDoc, overrides, meta, widgets, idPrefix }) {
-	return /* @__PURE__ */ jsx(Fragment, { children: parameters.map((param) => /* @__PURE__ */ jsxs("div", {
-		"data-parameter": param.name,
-		children: [
-			/* @__PURE__ */ jsxs("label", { children: [param.name, param.required && /* @__PURE__ */ jsx("span", {
-				"data-required": true,
-				children: "*"
-			})] }),
-			param.description && /* @__PURE__ */ jsx("span", {
-				"data-description": true,
-				children: param.description
-			}),
-			renderSchema(param.schema ?? { type: "string" }, rootDoc, {
-				meta: buildParamMeta(param, overrides, meta),
-				widgets,
-				rootPath: joinPath(idPrefix, param.name)
-			})
-		]
-	}, param.name)) });
+function ParameterList({ parameters, rootDoc, overrides, meta, widgets, idPrefix, diagnostics, pointerPrefix }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: parameters.map((param) => {
+		if (param.schema === void 0) {
+			emitDiagnostic(diagnostics, {
+				code: "parameter-missing-schema",
+				message: `Parameter "${param.name}" has no schema; rendering skipped`,
+				pointer: `${pointerPrefix}/parameters/${param.name}`,
+				detail: {
+					name: param.name,
+					location: param.location
+				}
+			});
+			return null;
+		}
+		return /* @__PURE__ */ jsxs("div", {
+			"data-parameter": param.name,
+			children: [
+				/* @__PURE__ */ jsxs("label", { children: [param.name, param.required && /* @__PURE__ */ jsx("span", {
+					"data-required": true,
+					children: "*"
+				})] }),
+				param.description && /* @__PURE__ */ jsx("span", {
+					"data-description": true,
+					children: param.description
+				}),
+				renderSchema(param.schema, rootDoc, {
+					meta: buildParamMeta(param, overrides, meta),
+					widgets,
+					rootPath: joinPath(idPrefix, param.name)
+				})
+			]
+		}, param.name);
+	}) });
 }
 function ResponseCard({ response, rootDoc, parsed, value, fields, meta, widgets, path, method, idPrefix }) {
 	if (response.schema === void 0) return /* @__PURE__ */ jsxs("div", {
@@ -382,6 +401,19 @@ function ResponseCard({ response, rootDoc, parsed, value, fields, meta, widgets,
 		]
 	});
 }
+/**
+* Compose the JSON Pointer prefix for an operation's Parameter Object
+* map. Paths conventionally begin with `/` so they live under
+* `#/paths/<escaped path>/<method>`; OpenAPI 3.1 webhook names (which
+* have no leading slash) live under `#/webhooks/<name>/<method>`.
+*
+* JSON Pointer (RFC 6901) requires `~` → `~0` and `/` → `~1`. The
+* escape order matters: `~` first to avoid double-escaping the `~1`
+* produced for `/`.
+*/
+function operationPointer(path, method) {
+	return `/${path.startsWith("/") ? "paths" : "webhooks"}/${path.replace(/~/g, "~0").replace(/\//g, "~1")}/${method}`;
+}
 function buildParamMeta(param, overrides, meta) {
 	const result = {};
 	if (param.description !== void 0) result.description = param.description;
@@ -391,20 +423,5 @@ function buildParamMeta(param, overrides, meta) {
 	if (meta !== void 0) for (const [k, v] of Object.entries(meta)) result[k] = v;
 	return Object.keys(result).length > 0 ? result : void 0;
 }
-/**
-* Extract root-level meta (title, description, readOnly, etc.) from a
-* JSON Schema node. Mirrors `extractRootMetaFromJson` in the adapter so
-* pre-normalised schemas (extracted from `getParsed`) still surface root
-* meta to the walker without an extra adapter round-trip.
-*/
-function extractRootMetaFromSchema(jsonSchema) {
-	const meta = {};
-	if (jsonSchema.readOnly === true) meta.readOnly = true;
-	if (jsonSchema.writeOnly === true) meta.writeOnly = true;
-	if (typeof jsonSchema.description === "string") meta.description = jsonSchema.description;
-	if (typeof jsonSchema.title === "string") meta.title = jsonSchema.title;
-	if (typeof jsonSchema.deprecated === "boolean") meta.deprecated = jsonSchema.deprecated;
-	return Object.keys(meta).length > 0 ? meta : void 0;
-}
 //#endregion
 export { ApiOperation, ApiParameters, ApiRequestBody, ApiResponse, ApiWebhook, ApiWebhooks };

package/dist/openapi/parser.d.mts

@@ -1,4 +1,5 @@
-import { m as JsonObject } from "../types-BrRMV0en.mjs";
+import { m as JsonObject } from "../types-BTB73MB8.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-Cbwak-ZX.mjs";
 
 //#region src/openapi/parser.d.ts
 interface OpenApiDocument {
@@ -86,17 +87,26 @@ interface LinkInfo {
 }
 declare function parseOpenApiDocument(doc: JsonObject): OpenApiDocument;
 declare function getSchema(parsed: OpenApiDocument, ref: string): JsonObject | undefined;
-declare function listOperations(parsed: OpenApiDocument): OperationInfo[];
-declare function getParameters(parsed: OpenApiDocument, path: string, method: string): ParameterInfo[];
+declare function listOperations(parsed: OpenApiDocument, diagnostics?: DiagnosticsOptions, seenIds?: Map<string, string>): OperationInfo[];
+declare function getParameters(parsed: OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): ParameterInfo[];
 declare function getRequestBody(parsed: OpenApiDocument, path: string, method: string): RequestBodyInfo | undefined;
-declare function getResponses(parsed: OpenApiDocument, path: string, method: string): ResponseInfo[];
+declare function getResponses(parsed: OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): ResponseInfo[];
 declare function getSecurityRequirements(parsed: OpenApiDocument, path: string, method: string): SecurityRequirement[];
 declare function getSecuritySchemes(parsed: OpenApiDocument): Map<string, SecurityScheme>;
-declare function getResponseHeaders(response: JsonObject, doc?: JsonObject): Map<string, HeaderInfo>;
-declare function listWebhooks(parsed: OpenApiDocument): WebhookInfo[];
+declare function getResponseHeaders(response: JsonObject, doc?: JsonObject, diagnostics?: DiagnosticsOptions): Map<string, HeaderInfo>;
+declare function listWebhooks(parsed: OpenApiDocument, diagnostics?: DiagnosticsOptions, seenIds?: Map<string, string>): WebhookInfo[];
+/**
+ * Enumerate every operation in the document — both the `paths` map and
+ * the OpenAPI 3.1 `webhooks` map — sharing a single `seenIds` cache so
+ * cross-list `operationId` collisions surface the same way as same-list
+ * collisions. Returns the path-operation list followed by webhook
+ * operations (flattened); callers that need the structured webhook
+ * grouping should call `listWebhooks` directly.
+ */
+declare function listAllOperations(parsed: OpenApiDocument, diagnostics?: DiagnosticsOptions): OperationInfo[];
 declare function getExternalDocs(obj: JsonObject): ExternalDocs | undefined;
 declare function getXmlInfo(schema: JsonObject): XmlInfo | undefined;
-declare function listCallbacks(parsed: OpenApiDocument, path: string, method: string): CallbackInfo[];
-declare function getLinks(parsed: OpenApiDocument, path: string, method: string, statusCode: string): LinkInfo[];
+declare function listCallbacks(parsed: OpenApiDocument, path: string, method: string, diagnostics?: DiagnosticsOptions): CallbackInfo[];
+declare function getLinks(parsed: OpenApiDocument, path: string, method: string, statusCode: string, diagnostics?: DiagnosticsOptions): LinkInfo[];
 //#endregion
-export { CallbackInfo, ExternalDocs, HeaderInfo, LinkInfo, OpenApiDocument, OperationInfo, ParameterInfo, ParameterLocation, RequestBodyInfo, ResponseInfo, SecurityRequirement, SecurityScheme, WebhookInfo, XmlInfo, getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };
+export { CallbackInfo, ExternalDocs, HeaderInfo, LinkInfo, OpenApiDocument, OperationInfo, ParameterInfo, ParameterLocation, RequestBodyInfo, ResponseInfo, SecurityRequirement, SecurityScheme, WebhookInfo, XmlInfo, getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listAllOperations, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };