@farming-labs/docs 0.2.120 → 0.2.121

package/dist/okf.d.mts

@@ -0,0 +1,42 @@
+import { DocsOkfActorTimestamp, DocsOkfConfig, DocsOkfTrustMetadata, DocsOkfTrustMetadataInput } from "./types.mjs";
+
+//#region src/okf.d.ts
+declare const DOCS_OKF_VERSION = "0.2";
+declare const DOCS_OKF_BUNDLE_FORMAT = "open-knowledge-format.v0.2";
+declare const DEFAULT_DOCS_OKF_ROUTE = "/.well-known/okf.json";
+interface DocsOkfPageLike {
+  url: string;
+  title: string;
+  canonicalUrl?: string;
+  sourcePath?: string;
+  lastModified?: string;
+  lastmod?: string;
+  okf?: DocsOkfTrustMetadataInput;
+}
+interface DocsOkfResolvedConfig extends DocsOkfTrustMetadataInput {
+  enabled: boolean;
+  route: string;
+  generatedBy: string;
+  staleAfterDays?: number;
+}
+interface DocsOkfKnowledgeDocument {
+  id: string;
+  url: string;
+  title: string;
+  content?: string;
+  trust: DocsOkfTrustMetadata;
+}
+interface DocsOkfBundle {
+  format: typeof DOCS_OKF_BUNDLE_FORMAT;
+  spec_version: typeof DOCS_OKF_VERSION;
+  generated: DocsOkfActorTimestamp;
+  documents: DocsOkfKnowledgeDocument[];
+}
+declare function normalizeDocsOkfTrustMetadataInput(value: unknown): DocsOkfTrustMetadataInput | undefined;
+declare function resolveDocsOkfConfig(value?: boolean | DocsOkfConfig): DocsOkfResolvedConfig;
+declare function resolveDocsOkfTrustMetadata(page: DocsOkfPageLike, value?: boolean | DocsOkfConfig, now?: Date): DocsOkfTrustMetadata;
+declare function buildDocsOkfBundle(pages: readonly (DocsOkfPageLike & {
+  content?: string;
+})[], value?: boolean | DocsOkfConfig): DocsOkfBundle;
+//#endregion
+export { DEFAULT_DOCS_OKF_ROUTE, DOCS_OKF_BUNDLE_FORMAT, DOCS_OKF_VERSION, DocsOkfBundle, DocsOkfKnowledgeDocument, DocsOkfPageLike, DocsOkfResolvedConfig, buildDocsOkfBundle, normalizeDocsOkfTrustMetadataInput, resolveDocsOkfConfig, resolveDocsOkfTrustMetadata };

package/dist/okf.mjs

@@ -0,0 +1,145 @@
+//#region src/okf.ts
+const DOCS_OKF_VERSION = "0.2";
+const DOCS_OKF_BUNDLE_FORMAT = "open-knowledge-format.v0.2";
+const DEFAULT_DOCS_OKF_ROUTE = "/.well-known/okf.json";
+function cleanString(value) {
+	if (typeof value !== "string") return void 0;
+	return value.trim() || void 0;
+}
+function normalizeDate(value) {
+	if (value instanceof Date && Number.isFinite(value.getTime())) return value.toISOString();
+	const stringValue = cleanString(value);
+	if (!stringValue) return void 0;
+	const parsed = new Date(stringValue);
+	return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : void 0;
+}
+function normalizeDateOnly(value) {
+	return normalizeDate(value)?.slice(0, 10);
+}
+function normalizeStatus(value) {
+	return value === "draft" || value === "stable" || value === "deprecated" ? value : void 0;
+}
+function normalizeActorTimestamp(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const record = value;
+	const by = cleanString(record.by);
+	const at = normalizeDate(record.at);
+	return by && at ? {
+		by,
+		at
+	} : void 0;
+}
+function normalizeSource(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const record = value;
+	const resource = cleanString(record.resource);
+	if (!resource) return void 0;
+	const usageCount = typeof record.usage_count === "number" && Number.isInteger(record.usage_count) ? Math.max(0, record.usage_count) : void 0;
+	const usageWindowRecord = record.usage_window && typeof record.usage_window === "object" && !Array.isArray(record.usage_window) ? record.usage_window : void 0;
+	const usageWindow = usageWindowRecord ? {
+		...normalizeDate(usageWindowRecord.start) ? { start: normalizeDate(usageWindowRecord.start) } : {},
+		...normalizeDate(usageWindowRecord.end) ? { end: normalizeDate(usageWindowRecord.end) } : {}
+	} : void 0;
+	return {
+		resource,
+		...cleanString(record.id) ? { id: cleanString(record.id) } : {},
+		...cleanString(record.title) ? { title: cleanString(record.title) } : {},
+		...cleanString(record.author) ? { author: cleanString(record.author) } : {},
+		...usageCount !== void 0 ? { usage_count: usageCount } : {},
+		...normalizeDate(record.last_modified) ? { last_modified: normalizeDate(record.last_modified) } : {},
+		...usageWindow && Object.keys(usageWindow).length > 0 ? { usage_window: usageWindow } : {}
+	};
+}
+function normalizeDocsOkfTrustMetadataInput(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const record = value;
+	const sources = Array.isArray(record.sources) ? record.sources.flatMap((source) => {
+		const normalized = normalizeSource(source);
+		return normalized ? [normalized] : [];
+	}) : void 0;
+	const verified = Array.isArray(record.verified) ? record.verified.flatMap((entry) => {
+		const normalized = normalizeActorTimestamp(entry);
+		return normalized ? [normalized] : [];
+	}) : void 0;
+	const generated = normalizeActorTimestamp(record.generated);
+	const status = normalizeStatus(record.status);
+	const staleAfter = normalizeDateOnly(record.stale_after);
+	const result = {
+		...sources && sources.length > 0 ? { sources } : {},
+		...generated ? { generated } : {},
+		...verified && verified.length > 0 ? { verified } : {},
+		...status ? { status } : {},
+		...staleAfter ? { stale_after: staleAfter } : {}
+	};
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function resolveDocsOkfConfig(value) {
+	const config = value && typeof value === "object" ? value : {};
+	return {
+		enabled: value === true || typeof value === "object" && value !== null && value.enabled !== false,
+		route: cleanString(config.route) ?? DEFAULT_DOCS_OKF_ROUTE,
+		generatedBy: cleanString(config.generatedBy) ?? "software:@farming-labs/docs",
+		...Number.isInteger(config.staleAfterDays) && (config.staleAfterDays ?? 0) > 0 ? { staleAfterDays: config.staleAfterDays } : {},
+		...normalizeDocsOkfTrustMetadataInput(config)
+	};
+}
+function addDays(value, days) {
+	const parsed = new Date(value);
+	if (!Number.isFinite(parsed.getTime())) return void 0;
+	parsed.setUTCDate(parsed.getUTCDate() + days);
+	return parsed.toISOString().slice(0, 10);
+}
+function trustTier(verified) {
+	if (verified.some((entry) => entry.by.toLowerCase().startsWith("human:"))) return "human-reviewed";
+	return verified.length > 0 ? "machine-confirmed" : "unverified";
+}
+function resolveDocsOkfTrustMetadata(page, value, now = /* @__PURE__ */ new Date()) {
+	const config = resolveDocsOkfConfig(value);
+	const authored = normalizeDocsOkfTrustMetadataInput(page.okf) ?? {};
+	const bestTimestamp = normalizeDate(page.lastmod) ?? normalizeDate(page.lastModified);
+	const generated = authored.generated ?? config.generated ?? {
+		by: config.generatedBy,
+		at: bestTimestamp ?? "1970-01-01T00:00:00.000Z"
+	};
+	const sources = [...authored.sources ?? config.sources ?? []];
+	if (sources.length === 0) sources.push({
+		resource: page.canonicalUrl ?? page.url,
+		...page.sourcePath ? { id: page.sourcePath } : {},
+		title: page.title,
+		...bestTimestamp ? { last_modified: bestTimestamp } : {}
+	});
+	const verified = [...authored.verified ?? config.verified ?? []];
+	const staleAfter = authored.stale_after ?? config.stale_after ?? (config.staleAfterDays && bestTimestamp ? addDays(bestTimestamp, config.staleAfterDays) : void 0);
+	return {
+		sources,
+		generated,
+		verified,
+		status: authored.status ?? config.status ?? "stable",
+		...staleAfter ? { stale_after: staleAfter } : {},
+		trust_tier: trustTier(verified),
+		stale: staleAfter ? now.getTime() > (/* @__PURE__ */ new Date(`${staleAfter}T23:59:59.999Z`)).getTime() : false
+	};
+}
+function buildDocsOkfBundle(pages, value) {
+	const config = resolveDocsOkfConfig(value);
+	const documents = pages.map((page) => ({
+		id: page.sourcePath ?? page.url,
+		url: page.canonicalUrl ?? page.url,
+		title: page.title,
+		...page.content ? { content: page.content } : {},
+		trust: resolveDocsOkfTrustMetadata(page, config)
+	})).sort((left, right) => left.url.localeCompare(right.url));
+	const generatedAt = documents.reduce((latest, document) => document.trust.generated.at > latest ? document.trust.generated.at : latest, "1970-01-01T00:00:00.000Z");
+	return {
+		format: DOCS_OKF_BUNDLE_FORMAT,
+		spec_version: DOCS_OKF_VERSION,
+		generated: {
+			by: config.generatedBy,
+			at: generatedAt
+		},
+		documents
+	};
+}
+
+//#endregion
+export { DEFAULT_DOCS_OKF_ROUTE, DOCS_OKF_BUNDLE_FORMAT, DOCS_OKF_VERSION, buildDocsOkfBundle, normalizeDocsOkfTrustMetadataInput, resolveDocsOkfConfig, resolveDocsOkfTrustMetadata };

package/dist/openapi-contract.mjs

@@ -0,0 +1,154 @@
+//#region src/openapi-contract.ts
+const OPENAPI_HTTP_METHODS = [
+	"get",
+	"put",
+	"post",
+	"delete",
+	"options",
+	"head",
+	"patch",
+	"trace"
+];
+var OpenApiContractValidationError = class extends Error {
+	diagnostics;
+	constructor(result) {
+		const first = result.diagnostics[0];
+		const remaining = result.diagnostics.length - 1;
+		super(first ? `OpenAPI contract validation failed at ${first.path}: ${first.message}${remaining > 0 ? ` (${remaining} more ${remaining === 1 ? "error" : "errors"})` : ""}` : "OpenAPI contract validation failed.");
+		this.name = "OpenApiContractValidationError";
+		this.diagnostics = result.diagnostics;
+	}
+};
+function validateOpenApiContract(document) {
+	const state = {
+		diagnostics: [],
+		operationIds: /* @__PURE__ */ new Map(),
+		operationCount: 0,
+		activePathItems: /* @__PURE__ */ new WeakSet()
+	};
+	const hasOpenApi = Object.hasOwn(document, "openapi");
+	const hasSwagger = Object.hasOwn(document, "swagger");
+	let dialect;
+	let version;
+	if (hasOpenApi && hasSwagger) addDiagnostic(state, "conflicting-version-fields", "/", "Use either the `openapi` field or the `swagger` field, not both.");
+	else if (hasOpenApi) {
+		dialect = "openapi";
+		version = validateOpenApiVersion(document.openapi, state);
+	} else if (hasSwagger) {
+		dialect = "swagger";
+		version = validateSwaggerVersion(document.swagger, state);
+	} else addDiagnostic(state, "missing-version", "/", "The document must declare an `openapi` or `swagger` specification version.");
+	inspectPathItemMap(document.paths, "/paths", "paths", state);
+	if (document.webhooks !== void 0) inspectPathItemMap(document.webhooks, "/webhooks", "webhooks", state);
+	return {
+		valid: state.diagnostics.length === 0,
+		dialect,
+		version,
+		operationCount: state.operationCount,
+		diagnostics: state.diagnostics
+	};
+}
+function assertValidOpenApiContract(document) {
+	const result = validateOpenApiContract(document);
+	if (!result.valid) throw new OpenApiContractValidationError(result);
+}
+function validateOpenApiVersion(value, state) {
+	if (typeof value !== "string" || !/^\d+\.\d+\.\d+$/.test(value)) {
+		addDiagnostic(state, "invalid-version", "/openapi", "`openapi` must be a stable major.minor.patch version string.");
+		return;
+	}
+	if (!/^3\.(?:0|1|2)\.\d+$/.test(value)) addDiagnostic(state, "unsupported-version", "/openapi", `OpenAPI ${value} is not supported. Supported families are 3.0.x, 3.1.x, and 3.2.x.`);
+	return value;
+}
+function validateSwaggerVersion(value, state) {
+	if (typeof value !== "string") {
+		addDiagnostic(state, "invalid-version", "/swagger", "`swagger` must be the string `2.0`.");
+		return;
+	}
+	if (value !== "2.0") addDiagnostic(state, "unsupported-version", "/swagger", `Swagger ${value} is not supported. The supported Swagger version is 2.0.`);
+	return value;
+}
+function inspectPathItemMap(value, pointer, kind, state) {
+	if (value === void 0) return;
+	if (!isRecord(value)) {
+		addDiagnostic(state, kind === "paths" ? "invalid-paths" : kind === "webhooks" ? "invalid-webhooks" : "invalid-callbacks", pointer, `\`${kind}\` must be an object.`);
+		return;
+	}
+	for (const [key, pathItem] of Object.entries(value)) {
+		if (key.startsWith("x-")) continue;
+		const pathPointer = `${pointer}/${escapeJsonPointer(key)}`;
+		if (!isRecord(pathItem)) {
+			addDiagnostic(state, "invalid-path-item", pathPointer, "Path items must be objects or Reference Objects.");
+			continue;
+		}
+		inspectPathItem(pathItem, pathPointer, state);
+	}
+}
+function inspectPathItem(pathItem, pointer, state) {
+	if (state.activePathItems.has(pathItem)) return;
+	state.activePathItems.add(pathItem);
+	try {
+		for (const method of OPENAPI_HTTP_METHODS) {
+			const operation = pathItem[method];
+			if (operation === void 0) continue;
+			const operationPointer = `${pointer}/${method}`;
+			if (!isRecord(operation)) {
+				addDiagnostic(state, "invalid-operation", operationPointer, `The ${method.toUpperCase()} operation must be an object.`);
+				continue;
+			}
+			state.operationCount += 1;
+			inspectOperationId(operation.operationId, `${operationPointer}/operationId`, state);
+			inspectCallbacks(operation.callbacks, `${operationPointer}/callbacks`, state);
+		}
+	} finally {
+		state.activePathItems.delete(pathItem);
+	}
+}
+function inspectOperationId(value, pointer, state) {
+	if (value === void 0) return;
+	if (typeof value !== "string" || value.trim().length === 0) {
+		addDiagnostic(state, "invalid-operation-id", pointer, "`operationId` must be a non-empty string when provided.");
+		return;
+	}
+	const firstPath = state.operationIds.get(value);
+	if (firstPath) {
+		addDiagnostic(state, "duplicate-operation-id", pointer, `The operationId \`${value}\` is already used at ${firstPath}.`, firstPath);
+		return;
+	}
+	state.operationIds.set(value, pointer);
+}
+function inspectCallbacks(value, pointer, state) {
+	if (value === void 0) return;
+	if (!isRecord(value)) {
+		addDiagnostic(state, "invalid-callbacks", pointer, "`callbacks` must be an object.");
+		return;
+	}
+	for (const [callbackName, callback] of Object.entries(value)) {
+		if (callbackName.startsWith("x-")) continue;
+		const callbackPointer = `${pointer}/${escapeJsonPointer(callbackName)}`;
+		if (!isRecord(callback)) {
+			addDiagnostic(state, "invalid-callbacks", callbackPointer, "Callback entries must be Callback Objects or Reference Objects.");
+			continue;
+		}
+		if (typeof callback.$ref === "string") continue;
+		inspectPathItemMap(callback, callbackPointer, "callbacks", state);
+	}
+}
+function addDiagnostic(state, code, path, message, relatedPath) {
+	state.diagnostics.push({
+		severity: "error",
+		code,
+		path,
+		message,
+		relatedPath
+	});
+}
+function escapeJsonPointer(value) {
+	return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+//#endregion
+export { assertValidOpenApiContract, validateOpenApiContract };

package/dist/{openapi-mcp-node-C4jUpZG6.mjs → openapi-mcp-node.mjs}

@@ -40,4 +40,4 @@ async function validateDocsOpenApiMcpUrl(url, config) {
 }
 
 //#endregion
-export { validateDocsOpenApiMcpUrl as t };
+export { validateDocsOpenApiMcpUrl };

package/dist/openapi-mcp.d.mts

@@ -0,0 +1,26 @@
+import { DocsOpenApiMcpConfig } from "./types.mjs";
+
+//#region src/openapi-mcp.d.ts
+interface DocsOpenApiMcpParameter {
+  name: string;
+  in: "path" | "query" | "header" | "cookie";
+  required: boolean;
+}
+interface DocsOpenApiMcpOperation {
+  toolName: string;
+  operationId: string;
+  method: string;
+  path: string;
+  title: string;
+  description?: string;
+  parameters: DocsOpenApiMcpParameter[];
+  security: Array<Record<string, string[]>>;
+  securitySchemes: Record<string, unknown>;
+  readOnly: boolean;
+  destructive: boolean;
+  idempotent: boolean;
+}
+declare function resolveDocsOpenApiMcpOperations(document: Record<string, unknown>, config?: DocsOpenApiMcpConfig): DocsOpenApiMcpOperation[];
+declare function resolveDocsOpenApiMcpBaseUrl(document: Record<string, unknown>, config: DocsOpenApiMcpConfig): string | undefined;
+//#endregion
+export { DocsOpenApiMcpOperation, DocsOpenApiMcpParameter, resolveDocsOpenApiMcpBaseUrl, resolveDocsOpenApiMcpOperations };

package/dist/openapi-mcp.mjs

@@ -0,0 +1,132 @@
+import { buildNormalizedOpenApiModel } from "./openapi-operations.mjs";
+
+//#region src/openapi-mcp.ts
+const OPENAPI_RATE_WINDOW_MS = 6e4;
+const openApiRateWindows = /* @__PURE__ */ new Map();
+function acquireDocsOpenApiMcpBudget(key, config, now = Date.now()) {
+	const requestsPerMinute = Math.max(1, config.requestsPerMinute ?? 60);
+	const maxConcurrentRequests = Math.max(1, config.maxConcurrentRequests ?? 4);
+	let window = openApiRateWindows.get(key);
+	if (!window || now - window.startedAt >= OPENAPI_RATE_WINDOW_MS) {
+		window = {
+			startedAt: now,
+			count: 0,
+			active: window?.active ?? 0
+		};
+		openApiRateWindows.set(key, window);
+	}
+	if (window.count >= requestsPerMinute) throw new Error("OpenAPI MCP rate limit exceeded for this principal and operation.");
+	if (window.active >= maxConcurrentRequests) throw new Error("OpenAPI MCP concurrency limit exceeded for this principal and operation.");
+	window.count += 1;
+	window.active += 1;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		window.active = Math.max(0, window.active - 1);
+	};
+}
+async function readDocsOpenApiMcpResponse(response, maxBytes = 1e6) {
+	const limit = Math.max(1, maxBytes);
+	if (!response.body) return {
+		text: "",
+		truncated: false
+	};
+	const reader = response.body.getReader();
+	const chunks = [];
+	let used = 0;
+	let truncated = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (used + value.byteLength > limit) {
+				const remaining = limit - used;
+				if (remaining > 0) chunks.push(value.subarray(0, remaining));
+				used = limit;
+				truncated = true;
+				await reader.cancel("OpenAPI MCP response byte limit reached");
+				break;
+			}
+			chunks.push(value);
+			used += value.byteLength;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(used);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return {
+		text: new TextDecoder().decode(bytes),
+		truncated
+	};
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function sanitizeToolName(value) {
+	return `api_${value.trim().replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 56) || "operation"}`;
+}
+function operationExtensionEnabled(operation) {
+	const extension = operation.extensions["x-farming-labs-mcp"];
+	return extension === true || asRecord(extension)?.enabled === true;
+}
+function resolveDocsOpenApiMcpOperations(document, config) {
+	if (!config || config.enabled === false) return [];
+	const allow = new Set((config.operations ?? []).map((value) => value.trim()).filter(Boolean));
+	const model = buildNormalizedOpenApiModel(document);
+	const operations = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const operation of model.operations) {
+		if (operation.method === "TRACE") continue;
+		if (!(allow.has(operation.operationId) || allow.has(operation.selector) || operationExtensionEnabled(operation))) continue;
+		if (![
+			"GET",
+			"HEAD",
+			"OPTIONS"
+		].includes(operation.method) && config.allowMutations !== true) continue;
+		const toolName = sanitizeToolName(operation.operationId);
+		if (names.has(toolName)) throw new Error(`OpenAPI MCP tool name collision: ${toolName}`);
+		names.add(toolName);
+		operations.push({
+			toolName,
+			operationId: operation.operationId,
+			method: operation.method,
+			path: operation.path,
+			title: operation.title,
+			...operation.description ? { description: operation.description } : {},
+			parameters: operation.parameters.flatMap((parameter) => {
+				if (parameter.in !== "path" && parameter.in !== "query" && parameter.in !== "header" && parameter.in !== "cookie") return [];
+				return [{
+					name: parameter.name,
+					in: parameter.in,
+					required: parameter.required
+				}];
+			}),
+			security: operation.security,
+			securitySchemes: operation.securitySchemes,
+			readOnly: operation.method === "GET" || operation.method === "HEAD",
+			destructive: operation.method === "DELETE",
+			idempotent: [
+				"GET",
+				"HEAD",
+				"PUT",
+				"DELETE",
+				"OPTIONS"
+			].includes(operation.method)
+		});
+	}
+	return operations.sort((left, right) => left.toolName.localeCompare(right.toolName));
+}
+function resolveDocsOpenApiMcpBaseUrl(document, config) {
+	const configured = config.baseUrl?.trim();
+	if (configured) return configured;
+	return buildNormalizedOpenApiModel(document).servers[0];
+}
+
+//#endregion
+export { acquireDocsOpenApiMcpBudget, readDocsOpenApiMcpResponse, resolveDocsOpenApiMcpBaseUrl, resolveDocsOpenApiMcpOperations };

package/dist/openapi-operations.d.mts

@@ -0,0 +1,71 @@
+//#region src/openapi-operations.d.ts
+declare const OPENAPI_OPERATION_METHODS: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+type OpenApiOperationMethod = Uppercase<(typeof OPENAPI_OPERATION_METHODS)[number]>;
+interface NormalizedOpenApiExample {
+  name: string;
+  location: "parameter" | "request" | "response";
+  summary?: string;
+  description?: string;
+  mediaType?: string;
+  status?: string;
+  value?: unknown;
+  externalValue?: string;
+}
+interface NormalizedOpenApiMediaType {
+  mediaType: string;
+  schema?: unknown;
+  examples: NormalizedOpenApiExample[];
+}
+interface NormalizedOpenApiParameter {
+  name: string;
+  in: string;
+  required: boolean;
+  description?: string;
+  schema?: unknown;
+  examples: NormalizedOpenApiExample[];
+}
+interface NormalizedOpenApiRequestBody {
+  required: boolean;
+  description?: string;
+  content: NormalizedOpenApiMediaType[];
+}
+interface NormalizedOpenApiResponse {
+  status: string;
+  description?: string;
+  content: NormalizedOpenApiMediaType[];
+}
+interface NormalizedOpenApiOperation {
+  id: string;
+  operationId: string;
+  operationIdSource: "explicit" | "generated";
+  slug: string;
+  selector: string;
+  pointer: string;
+  method: OpenApiOperationMethod;
+  path: string;
+  title: string;
+  summary?: string;
+  description?: string;
+  tags: string[];
+  deprecated: boolean;
+  parameters: NormalizedOpenApiParameter[];
+  requestBody?: NormalizedOpenApiRequestBody;
+  responses: NormalizedOpenApiResponse[];
+  examples: NormalizedOpenApiExample[];
+  security: Array<Record<string, string[]>>;
+  securitySchemes: Record<string, unknown>;
+  servers: string[];
+  extensions: Record<string, unknown>;
+}
+interface NormalizedOpenApiModel {
+  title: string;
+  version: string;
+  specificationVersion: string;
+  servers: string[];
+  tags: string[];
+  operationCount: number;
+  operations: NormalizedOpenApiOperation[];
+}
+declare function buildNormalizedOpenApiModel(document: Record<string, unknown>): NormalizedOpenApiModel;
+//#endregion
+export { NormalizedOpenApiExample, NormalizedOpenApiMediaType, NormalizedOpenApiModel, NormalizedOpenApiOperation, NormalizedOpenApiParameter, NormalizedOpenApiRequestBody, NormalizedOpenApiResponse, OPENAPI_OPERATION_METHODS, OpenApiOperationMethod, buildNormalizedOpenApiModel };

package/dist/{openapi-operations-DFpaqOqA.mjs → openapi-operations.mjs}

@@ -321,4 +321,4 @@ function escapeJsonPointer(value) {
 }
 
 //#endregion
-export { buildNormalizedOpenApiModel as n, OPENAPI_OPERATION_METHODS as t };
+export { OPENAPI_OPERATION_METHODS, buildNormalizedOpenApiModel };