@gitbook/react-openapi 1.5.1 → 1.5.3

package/dist/OpenAPIWebhook.d.ts

@@ -0,0 +1,15 @@
+import { OpenAPIContextInput } from "./context.js";
+import { OpenAPIWebhookData } from "./types.js";
+import * as react0 from "react";
+
+//#region src/OpenAPIWebhook.d.ts
+/**
+ * Display an interactive OpenAPI webhook.
+ */
+declare function OpenAPIWebhook(props: {
+  className?: string;
+  data: OpenAPIWebhookData;
+  context: OpenAPIContextInput;
+}): react0.JSX.Element;
+//#endregion
+export { OpenAPIWebhook };

package/dist/OpenAPIWebhook.js

@@ -0,0 +1,28 @@
+import { resolveOpenAPIContext } from "./context.js";
+import { OpenAPIColumnSpec } from "./common/OpenAPIColumnSpec.js";
+import { OpenAPISummary } from "./common/OpenAPISummary.js";
+import { OpenAPIWebhookExample } from "./OpenAPIWebhookExample.js";
+import clsx from "classnames";
+
+//#region src/OpenAPIWebhook.tsx
+/**
+* Display an interactive OpenAPI webhook.
+*/
+function OpenAPIWebhook(props) {
+	const { className, data, context: contextInput } = props;
+	const context = resolveOpenAPIContext(contextInput);
+	return <div className={clsx("openapi-webhook", className)}>
+            <OpenAPISummary data={data} context={context} />
+            <div className="openapi-columns">
+                <OpenAPIColumnSpec data={data} context={context} />
+                <div className="openapi-column-preview">
+                    <div className="openapi-column-preview-body">
+                        <OpenAPIWebhookExample data={data} context={context} />
+                    </div>
+                </div>
+            </div>
+        </div>;
+}
+
+//#endregion
+export { OpenAPIWebhook };

package/dist/OpenAPIWebhookExample.js

@@ -0,0 +1,40 @@
+import { OpenAPIEmptyExample } from "./OpenAPIExample.js";
+import { createStateKey } from "./utils.js";
+import { getOpenAPIClientContext } from "./context.js";
+import { getExamples } from "./util/example.js";
+import { OpenAPIMediaTypeContent } from "./OpenAPIMediaType.js";
+
+//#region src/OpenAPIWebhookExample.tsx
+function OpenAPIWebhookExample(props) {
+	const { data, context } = props;
+	const { operation } = data;
+	const items = (() => {
+		if (!operation.requestBody) return [];
+		return Object.entries(operation.requestBody.content).map(([key, value]) => {
+			if (!value?.schema) return {
+				key,
+				label: key,
+				body: <OpenAPIEmptyExample context={context} />
+			};
+			return {
+				key,
+				label: key,
+				body: <></>,
+				examples: getExamples({
+					mediaTypeObject: value,
+					mediaType: key,
+					context
+				})
+			};
+		});
+	})();
+	return <div className="openapi-panel">
+            <h4 className="openapi-panel-heading">Payload</h4>
+            <div className="openapi-panel-body">
+                <OpenAPIMediaTypeContent selectIcon={context.icons.chevronDown} stateKey={createStateKey("request-body-media-type", context.blockKey)} items={items} context={getOpenAPIClientContext(context)} />
+            </div>
+        </div>;
+}
+
+//#endregion
+export { OpenAPIWebhookExample };

package/dist/ScalarApiButton.js

@@ -0,0 +1,90 @@
+'use client';
+
+
+import { t } from "./translate.js";
+import { useOpenAPIOperationContext } from "./OpenAPIOperationContext.js";
+import { useOpenAPIPrefillContext } from "./OpenAPIPrefillContextProvider.js";
+import { resolveTryItPrefillForOperation } from "./util/tryit-prefill.js";
+import { Suspense, useEffect, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { ApiClientModalProvider, useApiClientModal } from "@scalar/api-client-react";
+import { createPortal } from "react-dom";
+
+//#region src/ScalarApiButton.tsx
+/**
+* Button which launches the Scalar API Client
+*/
+function ScalarApiButton(props) {
+	const { method, path, securities, servers, specUrl, context } = props;
+	const [isOpen, setIsOpen] = useState(false);
+	const controllerRef = useRef(null);
+	return <div className="scalar scalar-activate">
+            <button className="scalar-activate-button button" onClick={() => {
+		controllerRef.current?.openClient?.();
+		setIsOpen(true);
+	}}>
+                {t(context.translation, "test_it")}
+                <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 12" fill="currentColor">
+                    <path stroke="currentColor" strokeWidth="1.5" d="M1 10.05V1.43c0-.2.2-.31.37-.22l7.26 4.08c.17.1.17.33.01.43l-7.26 4.54a.25.25 0 0 1-.38-.21Z" />
+                </svg>
+            </button>
+
+            {isOpen && createPortal(<Suspense fallback={null}>
+                        <ScalarModal controllerRef={controllerRef} method={method} path={path} securities={securities} servers={servers} specUrl={specUrl} />
+                    </Suspense>, document.body)}
+        </div>;
+}
+function ScalarModal(props) {
+	const { method, path, securities, servers, specUrl, controllerRef } = props;
+	const prefillInputContext = useOpenAPIPrefillContext()();
+	const prefillConfig = resolveTryItPrefillForOperation({
+		operation: {
+			securities,
+			servers
+		},
+		prefillInputContext
+	});
+	return <ApiClientModalProvider configuration={{
+		url: specUrl,
+		...prefillConfig
+	}} initialRequest={{
+		method: toScalarHttpMethod(method),
+		path
+	}}>
+            <ScalarModalController method={method} path={path} controllerRef={controllerRef} />
+        </ApiClientModalProvider>;
+}
+function toScalarHttpMethod(method) {
+	return method.toUpperCase();
+}
+function ScalarModalController(props) {
+	const { method, path, controllerRef } = props;
+	const openScalarClient = useApiClientModal()?.open;
+	const { onOpenClient: trackClientOpening } = useOpenAPIOperationContext();
+	const openClient = useMemo(() => {
+		if (openScalarClient) return () => {
+			openScalarClient({
+				method: toScalarHttpMethod(method),
+				path,
+				_source: "gitbook"
+			});
+			trackClientOpening({
+				method,
+				path
+			});
+		};
+		return null;
+	}, [
+		openScalarClient,
+		method,
+		path,
+		trackClientOpening
+	]);
+	useImperativeHandle(controllerRef, () => ({ openClient: openClient ? () => openClient() : void 0 }), [openClient]);
+	useEffect(() => {
+		openClient?.();
+	}, [openClient]);
+	return null;
+}
+
+//#endregion
+export { ScalarApiButton };

package/dist/StaticSection.js

@@ -0,0 +1,37 @@
+import clsx from "classnames";
+import { forwardRef } from "react";
+
+//#region src/StaticSection.tsx
+function Section(props) {
+	return <div {...props} className={clsx("openapi-section", props.className)} />;
+}
+function SectionHeader(props) {
+	return <div {...props} className={clsx("openapi-section-header", props.className ? `${props.className}-header` : void 0)} />;
+}
+function SectionHeaderContent(props) {
+	return <div {...props} className={clsx("openapi-section-header-content", props.className && `${props.className}-header-content`)} />;
+}
+const SectionBody = forwardRef(function SectionBody$1(props, ref) {
+	return <div ref={ref} {...props} className={clsx("openapi-section-body", props.className && `${props.className}-body`)} />;
+});
+function SectionFooter(props) {
+	return <div {...props} className={clsx("openapi-section-footer", props.className && `${props.className}-footer`)} />;
+}
+function SectionFooterContent(props) {
+	return <div {...props} className={clsx("openapi-section-footer-content", props.className && `${props.className}-footer-content`)} />;
+}
+function StaticSection(props) {
+	const { className, header, children, footer } = props;
+	return <Section className={className}>
+            {header ? <SectionHeader className={className}>
+                    <SectionHeaderContent className={className}>{header}</SectionHeaderContent>
+                </SectionHeader> : null}
+            <SectionBody className={className}>{children}</SectionBody>
+            {footer ? <SectionFooter className={className}>
+                    <SectionFooterContent className={className}>{footer}</SectionFooterContent>
+                </SectionFooter> : null}
+        </Section>;
+}
+
+//#endregion
+export { Section, SectionBody, SectionHeader, SectionHeaderContent, StaticSection };

package/dist/code-samples.js

@@ -0,0 +1,305 @@
+import { json2xml } from "./json2xml.js";
+import { stringifyOpenAPI } from "./stringifyOpenAPI.js";
+import { isCSV, isFormData, isFormUrlEncoded, isGraphQL, isJSON, isPDF, isPlainObject, isText, isXML, isYAML } from "./contentTypeChecks.js";
+import yaml from "js-yaml";
+
+//#region src/code-samples.ts
+const codeSampleGenerators = [
+	{
+		id: "http",
+		label: "HTTP",
+		syntax: "http",
+		generate: ({ method, url: { origin, path }, headers = {}, body }) => {
+			if (body) {
+				const bodyContent = body ? stringifyOpenAPI(body) : "";
+				const encoder = new TextEncoder();
+				const bodyString$1 = BodyGenerators.getHTTPBody(body, headers);
+				if (bodyString$1) body = bodyString$1;
+				headers = {
+					...headers,
+					"Content-Length": encoder.encode(bodyContent).length.toString()
+				};
+			}
+			if (!headers.hasOwnProperty("Accept")) headers.Accept = "*/*";
+			const headerString = headers ? `${Object.entries(headers).map(([key, value]) => key.toLowerCase() !== "host" ? `${key}: ${value}` : "").join("\n")}\n` : "";
+			const bodyString = body ? `\n${body}` : "";
+			return `${method.toUpperCase()} ${decodeURI(path)} HTTP/1.1
+Host: ${origin.replaceAll(/https*:\/\//g, "")}
+${headerString}${bodyString}`;
+		}
+	},
+	{
+		id: "curl",
+		label: "cURL",
+		syntax: "bash",
+		generate: ({ method, url: { origin, path }, headers, body }) => {
+			const lines = ["curl -L"];
+			if (method.toUpperCase() !== "GET") lines.push(`--request ${method.toUpperCase()}`);
+			lines.push(`--url '${origin}${path}'`);
+			if (body) {
+				const bodyContent = BodyGenerators.getCurlBody(body, headers);
+				if (bodyContent) {
+					body = bodyContent.body;
+					headers = bodyContent.headers;
+				}
+			}
+			if (headers && Object.keys(headers).length > 0) Object.entries(headers).forEach(([key, value]) => {
+				lines.push(`--header '${key}: ${value}'`);
+			});
+			if (body) if (Array.isArray(body)) lines.push(...body);
+			else lines.push(body);
+			return buildHeredoc(lines);
+		}
+	},
+	{
+		id: "javascript",
+		label: "JavaScript",
+		syntax: "javascript",
+		generate: ({ method, url: { origin, path }, headers, body }) => {
+			let code = "";
+			if (body) {
+				const lines = BodyGenerators.getJavaScriptBody(body, headers);
+				if (lines) {
+					code += lines.code;
+					body = lines.body;
+					headers = lines.headers;
+				}
+			}
+			code += `const response = await fetch('${origin}${path}', {
+    method: '${method.toUpperCase()}',\n`;
+			if (headers && Object.keys(headers).length > 0) code += indent(`headers: ${stringifyOpenAPI(headers, null, 2)},\n`, 4);
+			if (body) code += indent(`body: ${body}\n`, 4);
+			code += "});\n\n";
+			code += "const data = await response.json();";
+			return code;
+		}
+	},
+	{
+		id: "python",
+		label: "Python",
+		syntax: "python",
+		generate: ({ method, url: { origin, path }, headers, body }) => {
+			const contentType = headers?.["Content-Type"];
+			let code = `${isJSON(contentType) ? "import json\n" : ""}import requests\n\n`;
+			if (body) {
+				const lines = BodyGenerators.getPythonBody(body, headers);
+				if (lines) {
+					code += lines.code;
+					body = lines.body;
+					headers = lines.headers;
+				}
+			}
+			code += `response = requests.${method.toLowerCase()}(\n`;
+			code += indent(`"${origin}${path}",\n`, 4);
+			if (headers && Object.keys(headers).length > 0) code += indent(`headers=${stringifyOpenAPI(headers)},\n`, 4);
+			if (body) if (body === "files") code += indent(`files=${body}\n`, 4);
+			else if (isJSON(contentType)) code += indent(`data=json.dumps(${body})\n`, 4);
+			else code += indent(`data=${body}\n`, 4);
+			code += ")\n\n";
+			code += "data = response.json()";
+			return code;
+		}
+	}
+];
+function indent(code, spaces) {
+	const indent$1 = " ".repeat(spaces);
+	return code.split("\n").map((line) => line ? indent$1 + line : "").join("\n");
+}
+function parseHostAndPath(url) {
+	try {
+		const urlObj = new URL(url);
+		const path = urlObj.pathname || "/";
+		return {
+			host: urlObj.host,
+			path
+		};
+	} catch (_e) {
+		const splitted = url.split("//");
+		const parts = (splitted[1] ? splitted[1] : url).split("/");
+		return {
+			host: parts.shift(),
+			path: `/${parts.join("/")}`
+		};
+	}
+}
+const BodyGenerators = {
+	getCurlBody(body, headers) {
+		if (!body || !headers) return void 0;
+		const headersCopy = { ...headers };
+		const contentType = headersCopy["Content-Type"] || "";
+		if (isFormData(contentType)) body = isPlainObject(body) ? Object.entries(body).map(([key, value]) => `--form '${key}=${String(value)}'`) : `--form 'file=@${body}'`;
+		else if (isFormUrlEncoded(contentType)) body = isPlainObject(body) ? `--data '${Object.entries(body).map(([key, value]) => `${key}=${String(value)}`).join("&")}'` : String(body);
+		else if (isText(contentType)) body = `--data '${String(body).replace(/"/g, "")}'`;
+		else if (isXML(contentType)) body = `--data-binary $'${convertBodyToXML(body)}'`;
+		else if (isCSV(contentType)) body = `--data-binary $'${stringifyOpenAPI(body).replace(/"/g, "").replace(/\\n/g, "\n")}'`;
+		else if (isGraphQL(contentType)) {
+			body = `--data '${stringifyOpenAPI(body)}'`;
+			headersCopy["Content-Type"] = "application/json";
+		} else if (isPDF(contentType)) body = `--data-binary '@${String(body)}'`;
+		else if (isYAML(contentType)) body = `--data-binary $'${yaml.dump(body).replace(/'/g, "").replace(/\\n/g, "\n")}'`;
+		else {
+			const jsonString = stringifyOpenAPI(body, null, 2).replace(/\\n/g, "\n");
+			if (jsonString.includes("'")) body = [
+				"--data @- <<'EOF'",
+				...jsonString.split("\n"),
+				"EOF"
+			];
+			else body = `--data '${jsonString}'`;
+		}
+		return {
+			body,
+			headers: headersCopy
+		};
+	},
+	getJavaScriptBody: (body, headers) => {
+		if (!body || !headers) return;
+		let code = "";
+		const headersCopy = { ...headers };
+		const contentType = headersCopy["Content-Type"] || "";
+		if (isFormData(contentType)) {
+			code += "const formData = new FormData();\n\n";
+			if (isPlainObject(body)) Object.entries(body).forEach(([key, value]) => {
+				code += `formData.append("${key}", "${String(value)}");\n`;
+			});
+			else if (typeof body === "string") code += `formData.append("file", "${body}");\n`;
+			code += "\n";
+			body = "formData";
+		} else if (isFormUrlEncoded(contentType)) {
+			code += "const params = new URLSearchParams();\n\n";
+			if (isPlainObject(body)) Object.entries(body).forEach(([key, value]) => {
+				code += `params.append("${key}", "${String(value)}");\n`;
+			});
+			code += "\n";
+			body = "params.toString()";
+		} else if (isGraphQL(contentType)) if (isPlainObject(body)) {
+			Object.entries(body).forEach(([key, value]) => {
+				code += `const ${key} = \`\n${indent(String(value), 4)}\`;\n\n`;
+			});
+			body = `JSON.stringify({ ${Object.keys(body).join(", ")} })`;
+			headersCopy["Content-Type"] = "application/json";
+		} else {
+			code += `const query = \`\n${indent(String(body), 4)}\`;\n\n`;
+			body = "JSON.stringify(query)";
+		}
+		else if (isCSV(contentType)) {
+			code += "const csv = `\n";
+			code += indent(String(body), 4);
+			code += "`;\n\n";
+			body = "csv";
+		} else if (isPDF(contentType)) {
+			code += "const formData = new FormData();\n\n";
+			code += `formData.append("file", "${body}");\n\n`;
+			body = "formData";
+		} else if (isXML(contentType)) {
+			code += "const xml = `\n";
+			code += indent(convertBodyToXML(body), 4);
+			code += "`;\n\n";
+			body = "xml";
+		} else if (isYAML(contentType)) {
+			code += `const yamlBody = \`\n${indent(yaml.dump(body), 4)}\`;\n\n`;
+			body = "yamlBody";
+		} else if (isText(contentType)) body = stringifyOpenAPI(body, null, 2);
+		else body = `JSON.stringify(${stringifyOpenAPI(body, null, 2)})`;
+		return {
+			body,
+			code,
+			headers: headersCopy
+		};
+	},
+	getPythonBody: (body, headers) => {
+		if (!body || !headers) return;
+		let code = "";
+		const contentType = headers["Content-Type"] || "";
+		if (isFormData(contentType)) {
+			code += "files = {\n";
+			if (isPlainObject(body)) Object.entries(body).forEach(([key, value]) => {
+				code += `${indent(`"${key}": "${String(value)}",`, 4)}\n`;
+			});
+			code += "}\n\n";
+			body = "files";
+		} else if (isPDF(contentType)) {
+			code += "files = {\n";
+			code += `${indent(`"file": "${body}",`, 4)}\n`;
+			code += "}\n\n";
+			body = "files";
+		} else if (isXML(contentType)) body = JSON.stringify(convertBodyToXML(body));
+		else if (isYAML(contentType)) {
+			code += `yamlBody = \"\"\"\n${indent(yaml.dump(body), 4)}\"\"\"\n\n`;
+			body = "yamlBody";
+		} else body = stringifyOpenAPI(body, (_key, value) => {
+			switch (value) {
+				case true: return "$$__TRUE__$$";
+				case false: return "$$__FALSE__$$";
+				case null: return "$$__NULL__$$";
+				default: return value;
+			}
+		}, 2).replaceAll("\"$$__TRUE__$$\"", "True").replaceAll("\"$$__FALSE__$$\"", "False").replaceAll("\"$$__NULL__$$\"", "None");
+		return {
+			body,
+			code,
+			headers
+		};
+	},
+	getHTTPBody: (body, headers) => {
+		if (!body || !headers) return void 0;
+		const contentType = headers["Content-Type"] || "";
+		const typeHandlers = {
+			pdf: () => `${stringifyOpenAPI(body, null, 2)}`,
+			formUrlEncoded: () => {
+				return `"${(isPlainObject(body) ? Object.entries(body).map(([key, value]) => `${key}=${stringifyOpenAPI(value)}`).join("&") : stringifyOpenAPI(body)).replace(/"/g, "'")}"`;
+			},
+			text: () => `"${String(body)}"`,
+			xml: () => {
+				return `"${convertBodyToXML(body)}"`;
+			},
+			yaml: () => `"${yaml.dump(body).replace(/"/g, "\\\"")}"`,
+			csv: () => `"${stringifyOpenAPI(body).replace(/"/g, "")}"`,
+			default: () => `${stringifyOpenAPI(body, null, 2)}`
+		};
+		if (isPDF(contentType)) return typeHandlers.pdf();
+		if (isFormUrlEncoded(contentType)) return typeHandlers.formUrlEncoded();
+		if (isText(contentType)) return typeHandlers.text();
+		if (isXML(contentType)) return typeHandlers.xml();
+		if (isYAML(contentType)) return typeHandlers.yaml();
+		if (isCSV(contentType)) return typeHandlers.csv();
+		return typeHandlers.default();
+	}
+};
+/**
+* Converts a body to XML format
+*/
+function convertBodyToXML(body) {
+	if (typeof body === "string" && body.trim().startsWith("<")) return body;
+	if (typeof body !== "object" || body === null) try {
+		body = JSON.parse(body);
+	} catch {
+		return body;
+	}
+	return json2xml(body).replace(/"/g, "").replace(/\\n/g, "\n").replace(/\\t/g, "	");
+}
+/**
+* Builds a heredoc string from an array of lines
+*/
+function buildHeredoc(lines) {
+	const separator = " \\\n";
+	let result = "";
+	let inHeredoc = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!line) continue;
+		const isHeredocStart = line.includes("<<'EOF'");
+		const isHeredocEnd = inHeredoc && line === "EOF";
+		if (isHeredocStart) {
+			inHeredoc = true;
+			result += `${i > 0 ? indent(line, 2) : line}\n`;
+		} else if (isHeredocEnd) {
+			inHeredoc = false;
+			result += line;
+		} else if (inHeredoc) result += `${indent(line, 2)}\n`;
+		else result += `${i > 0 ? indent(line, 2) : line}${i < lines.length - 1 ? separator : ""}`;
+	}
+	return result;
+}
+
+//#endregion
+export { codeSampleGenerators, parseHostAndPath };

package/dist/common/OpenAPIColumnSpec.js

@@ -0,0 +1,23 @@
+import { t } from "../translate.js";
+import { getOpenAPIClientContext } from "../context.js";
+import { OpenAPISpec } from "../OpenAPISpec.js";
+import { OpenAPIOperationDescription } from "./OpenAPIOperationDescription.js";
+
+//#region src/common/OpenAPIColumnSpec.tsx
+function OpenAPIColumnSpec(props) {
+	const { data, context } = props;
+	const { operation } = data;
+	const clientContext = getOpenAPIClientContext(context);
+	return <div className="openapi-column-spec">
+            {operation["x-deprecated-sunset"] ? <div className="openapi-deprecated-sunset openapi-description openapi-markdown">
+                    {t(context.translation, "deprecated_and_sunset_on", [<span key="date" className="openapi-deprecated-sunset-date">
+                            {operation["x-deprecated-sunset"]}
+                        </span>])}
+                </div> : null}
+            <OpenAPIOperationDescription operation={operation} context={context} />
+            <OpenAPISpec data={data} context={clientContext} />
+        </div>;
+}
+
+//#endregion
+export { OpenAPIColumnSpec };

package/dist/common/OpenAPIOperationDescription.js

@@ -0,0 +1,18 @@
+import { Markdown } from "../Markdown.js";
+import { resolveDescription } from "../utils.js";
+
+//#region src/common/OpenAPIOperationDescription.tsx
+function OpenAPIOperationDescription(props) {
+	const { operation } = props;
+	if (operation["x-gitbook-description-document"]) return <div className="openapi-intro">
+                {props.context.renderDocument({ document: operation["x-gitbook-description-document"] })}
+            </div>;
+	const description = resolveDescription(operation);
+	if (!description) return null;
+	return <div className="openapi-intro">
+            <Markdown className="openapi-description" source={description} />
+        </div>;
+}
+
+//#endregion
+export { OpenAPIOperationDescription };

package/dist/common/OpenAPIStability.js

@@ -0,0 +1,17 @@
+//#region src/common/OpenAPIStability.tsx
+const stabilityEnum = {
+	experimental: "Experimental",
+	alpha: "Alpha",
+	beta: "Beta"
+};
+function OpenAPIStability(props) {
+	const { stability } = props;
+	const foundStability = stabilityEnum[stability];
+	if (!foundStability) return null;
+	return <div className={`openapi-stability openapi-stability-${foundStability.toLowerCase()}`}>
+            {foundStability}
+        </div>;
+}
+
+//#endregion
+export { OpenAPIStability };

package/dist/common/OpenAPISummary.js

@@ -0,0 +1,27 @@
+import { OpenAPIPath } from "../OpenAPIPath.js";
+import { OpenAPIStability } from "./OpenAPIStability.js";
+
+//#region src/common/OpenAPISummary.tsx
+function OpenAPISummary(props) {
+	const { data, context } = props;
+	const { operation } = data;
+	const title = (() => {
+		if (operation.summary) return operation.summary;
+		if ("name" in data) return data.name;
+	})();
+	return <div className="openapi-summary" id={operation.summary ? void 0 : context.id}>
+            {(operation.deprecated || operation["x-stability"]) && <div className="openapi-summary-tags">
+                    {operation.deprecated && <div className="openapi-deprecated">Deprecated</div>}
+                    {operation["x-stability"] && <OpenAPIStability stability={operation["x-stability"]} />}
+                </div>}
+            {title ? context.renderHeading({
+		deprecated: operation.deprecated ?? false,
+		stability: operation["x-stability"],
+		title
+	}) : null}
+            {"path" in data ? <OpenAPIPath data={data} context={context} /> : null}
+        </div>;
+}
+
+//#endregion
+export { OpenAPISummary };

package/dist/contentTypeChecks.js

@@ -0,0 +1,34 @@
+//#region src/contentTypeChecks.ts
+function isJSON(contentType) {
+	return contentType?.toLowerCase().includes("application/json") || false;
+}
+function isXML(contentType) {
+	return contentType?.toLowerCase().includes("application/xml") || false;
+}
+function isYAML(contentType) {
+	return contentType?.toLowerCase().includes("application/yaml") || false;
+}
+function isGraphQL(contentType) {
+	return contentType?.toLowerCase().includes("application/graphql") || false;
+}
+function isCSV(contentType) {
+	return contentType?.toLowerCase().includes("text/csv") || false;
+}
+function isPDF(contentType) {
+	return contentType?.toLowerCase().includes("application/pdf") || false;
+}
+function isText(contentType) {
+	return contentType?.toLowerCase().includes("text/plain") || false;
+}
+function isFormUrlEncoded(contentType) {
+	return contentType?.toLowerCase().includes("application/x-www-form-urlencoded") || false;
+}
+function isFormData(contentType) {
+	return !!contentType && contentType.toLowerCase().includes("multipart/form-data");
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+export { isCSV, isFormData, isFormUrlEncoded, isGraphQL, isJSON, isPDF, isPlainObject, isText, isXML, isYAML };