@gitbook/react-openapi 1.4.2 → 1.5.1

package/dist/index.js

@@ -1,8 +1,3873 @@
-export * from './schemas';
-export * from './OpenAPIOperation';
-export * from './OpenAPIWebhook';
-export * from './OpenAPIOperationContext';
-export * from './OpenAPIPrefillContextProvider';
-export * from './resolveOpenAPIOperation';
-export * from './resolveOpenAPIWebhook';
-export { checkIsValidLocale } from './translations';
+import { createRequire } from "node:module";
+import clsx from "clsx";
+import yaml from "js-yaml";
+import { jsXml } from "json-xml-parse";
+import * as React$1 from "react";
+import React, { Fragment, Suspense, createContext, forwardRef, useCallback, useContext, useEffect, useId, useImperativeHandle, useMemo, useRef, useState } from "react";
+import { Button, Disclosure, DisclosurePanel, ListBox, ListBoxItem, Popover, Select, SelectValue, Tooltip, TooltipTrigger } from "react-aria-components";
+import { dereference, filterSelectedOpenAPISchemas } from "@gitbook/openapi-parser";
+import { createStore, useStore } from "zustand";
+import { ApiClientModalProvider, useApiClientModal } from "@scalar/api-client-react";
+import { useEventCallback } from "usehooks-ts";
+import { ExpressionRuntime, parseTemplate } from "@gitbook/expr";
+import { mergeProps, useButton, useDisclosure, useFocusRing, useId as useId$1 } from "react-aria";
+import "flatted";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/json2xml.ts
+/**
+* This function converts an object to XML.
+*/
+function json2xml(data) {
+	return jsXml.toXmlString(data, { beautify: true });
+}
+
+//#endregion
+//#region src/stringifyOpenAPI.ts
+/**
+* Stringify an OpenAPI object. Same API as JSON.stringify.
+*/
+function stringifyOpenAPI(value, replacer, space) {
+	return JSON.stringify(value, (key, value$1) => {
+		if (key.startsWith("x-gitbook-")) return;
+		if (replacer) return replacer(key, value$1);
+		return value$1;
+	}, space);
+}
+
+//#endregion
+//#region src/translate.tsx
+/**
+* Translate a string.
+*/
+function t(translation, id, ...args) {
+	const string = translation[id];
+	if (!string) throw new Error(`Translation not found for "${id}"`);
+	const parts = [];
+	let currentStringToReplace = string;
+	args.forEach((arg, i) => {
+		if (typeof arg === "string") currentStringToReplace = currentStringToReplace.replace(`\${${i + 1}}`, arg);
+		else {
+			const [partToPush, partToReplace] = currentStringToReplace.split(`\${${i + 1}}`);
+			if (partToPush === void 0 || partToReplace === void 0) throw new Error(`Invalid translation "${id}"`);
+			parts.push(<React.Fragment key={`string-${i}`}>{partToPush}</React.Fragment>);
+			parts.push(<React.Fragment key={`arg-${i}`}>{arg}</React.Fragment>);
+			currentStringToReplace = partToReplace;
+		}
+	});
+	if (!parts.length) return currentStringToReplace;
+	return <>
+            {parts}
+            {currentStringToReplace}
+        </>;
+}
+/**
+* Version of `t` that returns a string.
+*/
+function tString(translation, id, ...args) {
+	return reactToString(t(translation, id, ...args));
+}
+function reactToString(el) {
+	if (typeof el === "string" || typeof el === "number" || typeof el === "boolean") return `${el}`;
+	if (el === null || el === void 0) return "";
+	if (Array.isArray(el)) return el.map(reactToString).join("");
+	if (typeof el === "object" && "props" in el) return el.props.children.map(reactToString).join("");
+	throw new Error(`Unsupported type ${typeof el}`);
+}
+
+//#endregion
+//#region src/OpenAPIExample.tsx
+/**
+* Display an example.
+*/
+function OpenAPIExample(props) {
+	const { example, context, syntax } = props;
+	const code = stringifyExample({
+		example,
+		syntax
+	});
+	if (code === null) return <OpenAPIEmptyExample context={context} />;
+	return context.renderCodeBlock({
+		code,
+		syntax
+	});
+}
+function stringifyExample(args) {
+	const { example, syntax } = args;
+	if (!example.value) return null;
+	if (typeof example.value === "string") return example.value;
+	if (syntax === "xml") return json2xml(example.value);
+	if (syntax === "yaml") return yaml.dump(example.value).replace(/'/g, "").replace(/\\n/g, "\n");
+	return stringifyOpenAPI(example.value, null, 2);
+}
+/**
+* Empty response example.
+*/
+function OpenAPIEmptyExample(props) {
+	const { context } = props;
+	return <pre className="openapi-example-empty">
+            <p>{t(context.translation, "no_content")}</p>
+        </pre>;
+}
+
+//#endregion
+//#region src/Markdown.tsx
+function Markdown(props) {
+	const { source, className } = props;
+	return <div className={clsx("openapi-markdown", className)} dangerouslySetInnerHTML={{ __html: source }} />;
+}
+
+//#endregion
+//#region src/OpenAPICopyButton.tsx
+function OpenAPICopyButton(props) {
+	const { value, label, children, onPress, className, context, withTooltip = true } = props;
+	const [copied, setCopied] = useState(false);
+	const [isOpen, setIsOpen] = useState(false);
+	const handleCopy = () => {
+		if (!value) return;
+		navigator.clipboard.writeText(value).then(() => {
+			setIsOpen(true);
+			setCopied(true);
+			setTimeout(() => {
+				setCopied(false);
+				setIsOpen(false);
+			}, 2e3);
+		});
+	};
+	return <TooltipTrigger isOpen={isOpen} onOpenChange={setIsOpen} isDisabled={!withTooltip} closeDelay={200} delay={200}>
+            <Button type="button" preventFocusOnPress onPress={(e) => {
+		handleCopy();
+		onPress?.(e);
+	}} className={`openapi-copy-button ${className}`} {...props}>
+                {children}
+            </Button>
+
+            <Tooltip isOpen={isOpen} onOpenChange={setIsOpen} placement="top" offset={4} className="openapi-tooltip">
+                {copied ? t(context.translation, "copied") : label || t(context.translation, "copy_to_clipboard")}
+            </Tooltip>
+        </TooltipTrigger>;
+}
+
+//#endregion
+//#region src/OpenAPIDisclosure.tsx
+/**
+* Display an interactive OpenAPI disclosure.
+*/
+function OpenAPIDisclosure(props) {
+	const { icon, header, label, children, className } = props;
+	const [isExpanded, setIsExpanded] = useState(false);
+	return <Disclosure className={clsx("openapi-disclosure", className)} isExpanded={isExpanded} onExpandedChange={setIsExpanded}>
+            <Button slot="trigger" className="openapi-disclosure-trigger" style={({ isFocusVisible }) => ({ outline: isFocusVisible ? "2px solid rgb(var(--primary-color-500) / 0.4)" : "none" })}>
+                {header}
+                <div className="openapi-disclosure-trigger-label">
+                    <span>{typeof label === "function" ? label(isExpanded) : label}</span>
+                    {icon}
+                </div>
+            </Button>
+            <DisclosurePanel className="openapi-disclosure-panel">
+                {isExpanded ? children : null}
+            </DisclosurePanel>
+        </Disclosure>;
+}
+
+//#endregion
+//#region src/OpenAPISchemaName.tsx
+/**
+* Display the schema name row.
+* It includes the property name, type, required and deprecated status.
+*/
+function OpenAPISchemaName(props) {
+	const { schema, type, propertyName, required, isDiscriminatorProperty, context } = props;
+	const additionalItems = schema && getAdditionalItems(schema, context);
+	return <span className="openapi-schema-name">
+            {propertyName ? <span data-deprecated={schema?.deprecated} className="openapi-schema-propertyname">
+                    {propertyName}
+                </span> : null}
+            {isDiscriminatorProperty ? <span className="openapi-schema-discriminator">
+                    {t(context.translation, "discriminator")}
+                </span> : null}
+            {type || additionalItems ? <span>
+                    {schema?.const ? <span className="openapi-schema-type">const: {schema?.const}</span> : type ? <span className="openapi-schema-type">{type}</span> : null}
+                    {additionalItems ? <span className="openapi-schema-type">{additionalItems}</span> : null}
+                </span> : null}
+            {schema?.readOnly ? <span className="openapi-schema-readonly">
+                    {t(context.translation, "read_only")}
+                </span> : null}
+            {schema?.writeOnly ? <span className="openapi-schema-writeonly">
+                    {t(context.translation, "write_only")}
+                </span> : null}
+            {required === null ? null : required ? <span className="openapi-schema-required">
+                    {t(context.translation, "required")}
+                </span> : <span className="openapi-schema-optional">
+                    {t(context.translation, "optional")}
+                </span>}
+            {schema?.deprecated ? <span className="openapi-deprecated">{t(context.translation, "deprecated")}</span> : null}
+        </span>;
+}
+function getAdditionalItems(schema, context) {
+	let additionalItems = "";
+	if (schema.minimum || schema.minLength || schema.minItems) additionalItems += ` · ${tString(context.translation, "min").toLowerCase()}: ${schema.minimum || schema.minLength || schema.minItems}`;
+	if (schema.maximum || schema.maxLength || schema.maxItems) additionalItems += ` · ${tString(context.translation, "max").toLowerCase()}: ${schema.maximum || schema.maxLength || schema.maxItems}`;
+	if (schema.nullable) additionalItems = ` | ${tString(context.translation, "nullable").toLowerCase()}`;
+	return additionalItems;
+}
+
+//#endregion
+//#region src/decycle.ts
+const isObject = (value) => typeof value === "object" && value != null && !(value instanceof Boolean) && !(value instanceof Date) && !(value instanceof Number) && !(value instanceof RegExp) && !(value instanceof String);
+const toPointer = (parts) => `#${parts.map((part) => String(part).replace(/~/g, "~0").replace(/\//g, "~1")).join("/")}`;
+const decycle = () => {
+	const paths = /* @__PURE__ */ new WeakMap();
+	return function replacer(key, value) {
+		if (key !== "$reference" && isObject(value)) {
+			if (paths.has(value)) return { $reference: toPointer(paths.get(value)) };
+			paths.set(value, [...paths.get(this) ?? [], key]);
+		}
+		return value;
+	};
+};
+function retrocycle() {
+	const parents = /* @__PURE__ */ new WeakMap();
+	const keys = /* @__PURE__ */ new WeakMap();
+	const refs = /* @__PURE__ */ new Set();
+	function dereference$1(ref) {
+		const parts = ref.$reference.slice(1).split("/");
+		let key;
+		let value = this;
+		for (let i = 0; i < parts.length; i++) {
+			key = parts[i]?.replace(/~1/g, "/").replace(/~0/g, "~");
+			value = value[key];
+		}
+		const parent = parents.get(ref);
+		parent[keys.get(ref)] = value;
+	}
+	return function reviver(key, value) {
+		if (key === "$reference") refs.add(this);
+		else if (isObject(value)) if (key === "" && Object.keys(this).length === 1) refs.forEach(dereference$1, this);
+		else {
+			parents.set(value, this);
+			keys.set(value, key);
+		}
+		return value;
+	};
+}
+
+//#endregion
+//#region src/getDisclosureLabel.ts
+function getDisclosureLabel(props) {
+	const { schema, isExpanded, context } = props;
+	let label;
+	if (schema.type === "array" && !!schema.items) if (schema.items.oneOf) label = tString(context.translation, "available_items").toLowerCase();
+	else label = tString(context.translation, "properties").toLowerCase();
+	else label = tString(context.translation, "properties").toLowerCase();
+	return tString(context.translation, isExpanded ? "hide" : "show", label);
+}
+
+//#endregion
+//#region src/utils.ts
+function checkIsReference(input) {
+	return typeof input === "object" && !!input && "$ref" in input;
+}
+function createStateKey(key, scope) {
+	return scope ? `${scope}_${key}` : key;
+}
+/**
+* Check if an object has a description. Either at the root level or in items.
+*/
+function hasDescription(object) {
+	return "description" in object || "x-gitbook-description-html" in object;
+}
+/**
+* Resolve the description of an object.
+*/
+function resolveDescription(object) {
+	if (hasDescription(object)) return "x-gitbook-description-html" in object && typeof object["x-gitbook-description-html"] === "string" ? object["x-gitbook-description-html"].trim() : typeof object.description === "string" ? object.description.trim() : void 0;
+	if ("items" in object && typeof object.items === "object" && hasDescription(object.items)) return resolveDescription(object.items);
+}
+/**
+* Extract descriptions from an object.
+*/
+function extractDescriptions(object) {
+	return {
+		description: object.description,
+		"x-gitbook-description-html": "x-gitbook-description-html" in object ? object["x-gitbook-description-html"] : void 0
+	};
+}
+/**
+* Resolve the first example from an object.
+*/
+function resolveFirstExample(object) {
+	if ("examples" in object && typeof object.examples === "object" && object.examples) {
+		const firstKey = Object.keys(object.examples)[0];
+		if (firstKey && object.examples[firstKey]) return formatExample(object.examples[firstKey]);
+	}
+	if (shouldDisplayExample(object)) return formatExample(object.example);
+	if (object.items && typeof object.items === "object") return formatExample(object.items.example);
+}
+/**
+* Resolve the schema of a parameter.
+* Extract the description, example and deprecated from parameter.
+*/
+function resolveParameterSchema(parameter) {
+	const schema = checkIsReference(parameter.schema) ? void 0 : parameter.schema;
+	return {
+		...extractDescriptions(parameter),
+		example: resolveFirstExample(parameter),
+		deprecated: parameter.deprecated,
+		...schema
+	};
+}
+/**
+* Transform a parameter object to a property object.
+*/
+function parameterToProperty(parameter) {
+	if (checkIsReference(parameter)) return {
+		propertyName: parameter.$ref ?? "Unknown ref",
+		schema: {},
+		required: void 0
+	};
+	return {
+		propertyName: parameter.name,
+		schema: resolveParameterSchema(parameter),
+		required: parameter.required
+	};
+}
+/**
+* Format the example of a schema.
+*/
+function formatExample(example) {
+	if (typeof example === "string") return example.replace(/\n/g, " ").replace(/\s+/g, " ").replace(/([\{\}:,])\s+/g, "$1 ").replace(/\s+([\{\}:,])/g, " $1").trim();
+	return stringifyOpenAPI(example);
+}
+/**
+* Check if an example should be displayed.
+*/
+function shouldDisplayExample(schema) {
+	return typeof schema.example === "string" && !!schema.example || typeof schema.example === "number" || typeof schema.example === "boolean" || Array.isArray(schema.example) && schema.example.length > 0 || typeof schema.example === "object" && schema.example !== null && Object.keys(schema.example).length > 0;
+}
+/**
+* Get the class name for a status code.
+* 1xx: informational
+* 2xx: success
+* 3xx: redirect
+* 4xx, 5xx: error
+*/
+function getStatusCodeClassName(statusCode) {
+	switch (getStatusCodeCategory(statusCode)) {
+		case 1: return "informational";
+		case 2: return "success";
+		case 3: return "redirect";
+		case 4:
+		case 5: return "error";
+		default: return "unknown";
+	}
+}
+/**
+* Get a default label for a status code.
+* This is used when there is no label provided in the OpenAPI spec.
+* 1xx: Information
+* 2xx: Success
+* 3xx: Redirect
+* 4xx, 5xx: Error
+*/
+function getStatusCodeDefaultLabel(statusCode, context) {
+	switch (getStatusCodeCategory(statusCode)) {
+		case 1: return tString(context.translation, "information");
+		case 2: return tString(context.translation, "success");
+		case 3: return tString(context.translation, "redirect");
+		case 4:
+		case 5: return tString(context.translation, "error");
+		default: return "";
+	}
+}
+function getStatusCodeCategory(statusCode) {
+	const code = typeof statusCode === "string" ? Number.parseInt(statusCode, 10) : statusCode;
+	if (Number.isNaN(code) || code < 100 || code >= 600) return "unknown";
+	return Math.floor(code / 100);
+}
+function getSchemaTitle(schema) {
+	let type = "any";
+	if (schema.enum || schema["x-enumDescriptions"] || schema["x-gitbook-enum"]) type = `${schema.type} · enum`;
+	else if (schema.type === "array" && !!schema.items) type = `${getSchemaTitle(schema.items)}[]`;
+	else if (Array.isArray(schema.type)) type = schema.type.join(" | ");
+	else if (schema.type || schema.properties) {
+		type = schema.type ?? "object";
+		if (schema.format) type += ` · ${schema.format}`;
+		if (type === "object" && schema.title) type += ` · ${schema.title.replaceAll(" ", "")}`;
+	}
+	if ("anyOf" in schema) type = "any of";
+	else if ("oneOf" in schema) type = "one of";
+	else if ("allOf" in schema) type = "all of";
+	else if ("not" in schema) type = "not";
+	return type;
+}
+/**
+* Extract security information for an operation based on its security requirements and the spec security schemes.
+*/
+function extractOperationSecurityInfo(args) {
+	const { securityRequirement, securities } = args;
+	const securitiesMap = new Map(securities);
+	if (!securityRequirement || securityRequirement.length === 0) return securities.map(([key, security]) => ({
+		key,
+		label: key,
+		schemes: [security]
+	}));
+	return securityRequirement.map((requirement, idx) => {
+		const schemeKeys = Object.keys(requirement);
+		return {
+			key: `security-${idx}`,
+			label: schemeKeys.join(" & "),
+			schemes: schemeKeys.map((schemeKey) => securitiesMap.get(schemeKey)).filter((s) => s !== void 0)
+		};
+	});
+}
+
+//#endregion
+//#region src/OpenAPISchema.tsx
+/**
+* Render a property of an OpenAPI schema.
+*/
+function OpenAPISchemaProperty(props) {
+	const { circularRefs: parentCircularRefs, context, className, property,...rest } = props;
+	const { schema } = property;
+	const id = useId();
+	const circularRefId = parentCircularRefs.get(schema);
+	if (circularRefId) return <OpenAPISchemaCircularRef id={circularRefId} schema={schema} />;
+	const circularRefs = new Map(parentCircularRefs);
+	circularRefs.set(schema, id);
+	const properties = getSchemaProperties(schema);
+	const alternatives = getSchemaAlternatives(schema, new Set(circularRefs.keys()));
+	const header = <OpenAPISchemaPresentation context={context} property={property} />;
+	const content = (() => {
+		if (alternatives?.schemas) {
+			const { schemas, discriminator } = alternatives;
+			return <div className="openapi-schema-alternatives">
+                    {schemas.map((alternativeSchema, index) => <div key={index} className="openapi-schema-alternative">
+                            <OpenAPISchemaAlternative schema={alternativeSchema} discriminator={discriminator} circularRefs={circularRefs} context={context} />
+                            {index < schemas.length - 1 ? <OpenAPISchemaAlternativeSeparator schema={schema} context={context} /> : null}
+                        </div>)}
+                </div>;
+		}
+		if (properties?.length) return <OpenAPISchemaProperties$1 properties={properties} circularRefs={circularRefs} context={context} />;
+		return null;
+	})();
+	if (properties?.length) return <OpenAPIDisclosure icon={context.icons.plus} className={clsx("openapi-schema", className)} header={header} label={(isExpanded) => getDisclosureLabel({
+		schema,
+		isExpanded,
+		context
+	})} {...rest}>
+                {content}
+            </OpenAPIDisclosure>;
+	return <div id={id} {...rest} className={clsx("openapi-schema", className)}>
+            {header}
+            {content}
+        </div>;
+}
+/**
+* Render a set of properties of an OpenAPI schema.
+*/
+function OpenAPISchemaProperties$1(props) {
+	const { id, properties, circularRefs = /* @__PURE__ */ new Map(), context } = props;
+	return <div id={id} className="openapi-schema-properties">
+            {properties.map((property, index) => {
+		return <OpenAPISchemaProperty key={index} circularRefs={circularRefs} property={property} context={context} style={{ animationDelay: `${index * .02}s` }} />;
+	})}
+        </div>;
+}
+function OpenAPISchemaPropertiesFromServer(props) {
+	return <OpenAPISchemaProperties$1 id={props.id} properties={JSON.parse(props.properties, retrocycle())} context={props.context} />;
+}
+/**
+* Render a root schema (such as the request body or response body).
+*/
+function OpenAPIRootSchema$1(props) {
+	const { schema, context, circularRefs: parentCircularRefs = /* @__PURE__ */ new Map() } = props;
+	const id = useId();
+	const properties = getSchemaProperties(schema);
+	const description = resolveDescription(schema);
+	if (properties?.length) {
+		const circularRefs = new Map(parentCircularRefs);
+		circularRefs.set(schema, id);
+		return <>
+                {description ? <Markdown source={description} className="openapi-schema-root-description" /> : null}
+                <OpenAPISchemaProperties$1 properties={properties} circularRefs={circularRefs} context={context} />
+            </>;
+	}
+	return <OpenAPISchemaProperty className="openapi-schema-root" property={{ schema }} context={context} circularRefs={parentCircularRefs} />;
+}
+function OpenAPIRootSchemaFromServer(props) {
+	return <OpenAPIRootSchema$1 schema={JSON.parse(props.schema, retrocycle())} context={props.context} />;
+}
+/**
+* Render a tab for an alternative schema.
+* It renders directly the properties if relevant;
+* for primitives, it renders the schema itself.
+*/
+function OpenAPISchemaAlternative(props) {
+	const { schema, discriminator, circularRefs, context } = props;
+	const properties = getSchemaProperties(schema, discriminator);
+	return properties?.length ? <OpenAPIDisclosure icon={context.icons.plus} header={<OpenAPISchemaPresentation property={{ schema }} context={context} />} label={(isExpanded) => getDisclosureLabel({
+		schema,
+		isExpanded,
+		context
+	})}>
+            <OpenAPISchemaProperties$1 properties={properties} circularRefs={circularRefs} context={context} />
+        </OpenAPIDisclosure> : <OpenAPISchemaProperty property={{ schema }} circularRefs={circularRefs} context={context} />;
+}
+function OpenAPISchemaAlternativeSeparator(props) {
+	const { schema, context } = props;
+	const anyOf = schema.anyOf || schema.items?.anyOf;
+	const oneOf = schema.oneOf || schema.items?.oneOf;
+	const allOf = schema.allOf || schema.items?.allOf;
+	if (!anyOf && !oneOf && !allOf) return null;
+	return <span className="openapi-schema-alternative-separator">
+            {(anyOf || oneOf) && tString(context.translation, "or")}
+            {allOf && tString(context.translation, "and")}
+        </span>;
+}
+/**
+* Render a circular reference to a schema.
+*/
+function OpenAPISchemaCircularRef(props) {
+	const { id, schema } = props;
+	return <div className="openapi-schema-circular">
+            Circular reference to <a href={`#${id}`}>{getSchemaTitle(schema)}</a>{" "}
+            <span className="openapi-schema-circular-glyph">↩</span>
+        </div>;
+}
+/**
+* Render the enum value for a schema.
+*/
+function OpenAPISchemaEnum(props) {
+	const { schema, context } = props;
+	const enumValues = (() => {
+		if (schema["x-gitbook-enum"]) return Object.entries(schema["x-gitbook-enum"]).map(([name, { description }]) => {
+			return {
+				value: name,
+				description
+			};
+		});
+		if (schema["x-enumDescriptions"]) return Object.entries(schema["x-enumDescriptions"]).map(([value, description]) => {
+			return {
+				value,
+				description
+			};
+		});
+		return schema.enum?.map((value) => {
+			return {
+				value,
+				description: void 0
+			};
+		});
+	})();
+	if (!enumValues?.length) return null;
+	return <span className="openapi-schema-enum">
+            {tString(context.translation, "possible_values")}:{" "}
+            {enumValues.map((item, index) => <span key={index} className="openapi-schema-enum-value">
+                    <OpenAPICopyButton value={item.value} label={item.description} withTooltip={!!item.description} context={context}>
+                        <code>{`${item.value}`}</code>
+                    </OpenAPICopyButton>
+                </span>)}
+        </span>;
+}
+/**
+* Render the top row of a schema. e.g: name, type, and required status.
+*/
+function OpenAPISchemaPresentation(props) {
+	const { property: { schema, propertyName, required, isDiscriminatorProperty }, context } = props;
+	const description = resolveDescription(schema);
+	const example = resolveFirstExample(schema);
+	return <div className="openapi-schema-presentation">
+            <OpenAPISchemaName schema={schema} type={getSchemaTitle(schema)} propertyName={propertyName} isDiscriminatorProperty={isDiscriminatorProperty} required={required} context={context} />
+            {typeof schema["x-deprecated-sunset"] === "string" ? <div className="openapi-deprecated-sunset openapi-schema-description openapi-markdown">
+                    Sunset date:{" "}
+                    <span className="openapi-deprecated-sunset-date">
+                        {schema["x-deprecated-sunset"]}
+                    </span>
+                </div> : null}
+            {description ? <Markdown source={description} className="openapi-schema-description" /> : null}
+            {schema.default !== void 0 ? <span className="openapi-schema-default">
+                    Default:{" "}
+                    <code>
+                        {typeof schema.default === "string" && schema.default ? schema.default : stringifyOpenAPI(schema.default)}
+                    </code>
+                </span> : null}
+            {typeof example === "string" ? <span className="openapi-schema-example">
+                    Example: <code>{example}</code>
+                </span> : null}
+            {schema.pattern ? <span className="openapi-schema-pattern">
+                    Pattern: <code>{schema.pattern}</code>
+                </span> : null}
+            <OpenAPISchemaEnum schema={schema} context={context} />
+        </div>;
+}
+/**
+* Get the sub-properties of a schema.
+*/
+function getSchemaProperties(schema, discriminator) {
+	if (schema.type === "array" && schema.items && !checkIsReference(schema.items)) {
+		const items = schema.items;
+		const itemProperties = getSchemaProperties(items);
+		if (itemProperties) return itemProperties.map((prop) => ({
+			...prop,
+			isDiscriminatorProperty: discriminator?.propertyName === prop.propertyName
+		}));
+		if ((items.type === "string" || items.type === "number" || items.type === "boolean" || items.type === "integer") && !items.enum) return null;
+		return [{
+			propertyName: "items",
+			schema: items
+		}];
+	}
+	if (schema.type === "object" || schema.properties) {
+		const result = [];
+		if (schema.properties) Object.entries(schema.properties).forEach(([propertyName, propertySchema]) => {
+			if (checkIsReference(propertySchema)) return;
+			result.push({
+				propertyName,
+				required: Array.isArray(schema.required) ? schema.required.includes(propertyName) : void 0,
+				isDiscriminatorProperty: discriminator?.propertyName === propertyName,
+				schema: propertySchema
+			});
+		});
+		if (schema.additionalProperties && !checkIsReference(schema.additionalProperties)) result.push({
+			propertyName: "Other properties",
+			schema: schema.additionalProperties === true ? {} : schema.additionalProperties
+		});
+		return result;
+	}
+	return null;
+}
+/**
+* Get the alternatives to display for a schema.
+*/
+function getSchemaAlternatives(schema, ancestors = /* @__PURE__ */ new Set()) {
+	if (schema.items && ("oneOf" in schema.items || "allOf" in schema.items || "anyOf" in schema.items)) return getSchemaAlternatives(schema.items, ancestors);
+	const alternatives = (() => {
+		if (schema.anyOf) return [
+			"anyOf",
+			schema.anyOf,
+			schema.discriminator
+		];
+		if (schema.oneOf) return [
+			"oneOf",
+			schema.oneOf,
+			schema.discriminator
+		];
+		if (schema.allOf) return [
+			"allOf",
+			schema.allOf,
+			schema.discriminator
+		];
+		return null;
+	})();
+	if (!alternatives) return null;
+	const [type, schemas, discriminator] = alternatives;
+	return {
+		type,
+		schemas: mergeAlternatives(type, flattenAlternatives(type, schemas, new Set(ancestors).add(schema))) ?? [],
+		discriminator
+	};
+}
+const safeExtensions = [
+	"description",
+	"title",
+	"example",
+	"examples",
+	"default",
+	"readOnly",
+	"writeOnly",
+	"deprecated"
+];
+/**
+* Determine if a schema is safe to merge based on its properties
+*/
+function isSafeToMerge(schema) {
+	const keys = Object.keys(schema);
+	const coreProperties = [
+		"type",
+		"properties",
+		"required",
+		"nullable"
+	];
+	const coreKeys = keys.filter((key) => coreProperties.includes(key));
+	const unknownKeys = keys.filter((key) => !coreProperties.includes(key) && !safeExtensions.includes(key) && !key.startsWith("x-"));
+	return coreKeys.length > 0 && unknownKeys.length === 0;
+}
+/**
+* Merge alternatives of the same type into a single schema.
+* - Merge string enums
+* - Safely merge object schemas with compatible properties
+*/
+function mergeAlternatives(alternativeType, schemasOrRefs) {
+	switch (alternativeType) {
+		case "oneOf": return schemasOrRefs.reduce((acc, schemaOrRef) => {
+			const latest = acc.at(-1);
+			if (latest && latest.type === "string" && latest.enum && schemaOrRef.type === "string" && schemaOrRef.enum) {
+				latest.enum = Array.from(new Set([...latest.enum, ...schemaOrRef.enum]));
+				latest.nullable = latest.nullable || schemaOrRef.nullable;
+				return acc;
+			}
+			acc.push(schemaOrRef);
+			return acc;
+		}, []);
+		case "allOf": return schemasOrRefs.reduce((acc, schemaOrRef) => {
+			const latest = acc.at(-1);
+			if (latest && latest.type === "string" && latest.enum && schemaOrRef.type === "string" && schemaOrRef.enum) {
+				if (Object.keys(schemaOrRef).every((key) => [
+					"type",
+					"enum",
+					"nullable"
+				].includes(key))) {
+					latest.enum = Array.from(new Set([...latest.enum, ...schemaOrRef.enum]));
+					latest.nullable = latest.nullable || schemaOrRef.nullable;
+					return acc;
+				}
+			}
+			if (latest && latest.type === "object" && schemaOrRef.type === "object") {
+				const keys = Object.keys(schemaOrRef);
+				if (isSafeToMerge(schemaOrRef)) {
+					const safeKeys = keys.filter((key) => safeExtensions.includes(key));
+					const vendorKeys = keys.filter((key) => key.startsWith("x-"));
+					latest.properties = {
+						...latest.properties || {},
+						...schemaOrRef.properties || {}
+					};
+					latest.required = Array.from(new Set([...latest.required && Array.isArray(latest.required) ? latest.required : [], ...schemaOrRef.required && Array.isArray(schemaOrRef.required) ? schemaOrRef.required : []]));
+					latest.nullable = latest.nullable || schemaOrRef.nullable;
+					[...vendorKeys, ...safeKeys].forEach((key) => {
+						if (typeof latest[key] === "object" && typeof schemaOrRef[key] === "object") latest[key] = {
+							...latest[key],
+							...schemaOrRef[key]
+						};
+						else latest[key] = schemaOrRef[key];
+					});
+					return acc;
+				}
+			}
+			acc.push(schemaOrRef);
+			return acc;
+		}, []);
+		default: return schemasOrRefs;
+	}
+}
+function flattenAlternatives(alternativeType, schemasOrRefs, ancestors) {
+	const latestAncestor = Array.from(ancestors).pop();
+	return schemasOrRefs.reduce((acc, schemaOrRef) => {
+		if (checkIsReference(schemaOrRef)) return acc;
+		if (schemaOrRef[alternativeType] && !ancestors.has(schemaOrRef)) {
+			const alternatives = getSchemaAlternatives(schemaOrRef, ancestors);
+			if (alternatives?.schemas) acc.push(...alternatives.schemas.map((schema$1) => ({
+				...schema$1,
+				required: mergeRequiredFields(schema$1, latestAncestor)
+			})));
+			return acc;
+		}
+		const schema = {
+			...schemaOrRef,
+			required: mergeRequiredFields(schemaOrRef, latestAncestor)
+		};
+		acc.push(schema);
+		return acc;
+	}, []);
+}
+/**
+* Merge the required fields of a schema with the required fields of its latest ancestor.
+*/
+function mergeRequiredFields(schemaOrRef, latestAncestor) {
+	if (!schemaOrRef.required && !latestAncestor?.required) return;
+	if (checkIsReference(schemaOrRef)) return latestAncestor?.required;
+	return Array.from(new Set([...latestAncestor?.required || [], ...schemaOrRef.required || []]));
+}
+
+//#endregion
+//#region src/OpenAPISchemaServer.tsx
+function OpenAPISchemaProperties(props) {
+	return <OpenAPISchemaPropertiesFromServer id={props.id} properties={JSON.stringify(props.properties, decycle())} context={props.context} />;
+}
+function OpenAPIRootSchema(props) {
+	return <OpenAPIRootSchemaFromServer schema={JSON.stringify(props.schema, decycle())} context={props.context} />;
+}
+
+//#endregion
+//#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
+//#region src/translations/de.ts
+const de = {
+	required: "Erforderlich",
+	deprecated: "Veraltet",
+	deprecated_and_sunset_on: "Diese Operation ist veraltet und wird am ${1} eingestellt.",
+	stability_experimental: "Experimentell",
+	stability_alpha: "Alpha",
+	stability_beta: "Beta",
+	discriminator: "Diskriminator",
+	copy_to_clipboard: "In die Zwischenablage kopieren",
+	copied: "Kopiert",
+	no_content: "Kein Inhalt",
+	unresolved_reference: "Nicht aufgelöste Referenz",
+	circular_reference: "Zirkuläre Referenz",
+	read_only: "Nur lesen",
+	write_only: "Nur schreiben",
+	optional: "Optional",
+	min: "Min",
+	max: "Max",
+	nullable: "Nullfähig",
+	body: "Rumpf",
+	payload: "Nutzlast",
+	headers: "Header",
+	header: "Header",
+	authorizations: "Autorisierungen",
+	responses: "Antworten",
+	response: "Antwort",
+	path_parameters: "Pfadparameter",
+	query_parameters: "Abfrageparameter",
+	header_parameters: "Header-Parameter",
+	attributes: "Attribute",
+	test_it: "Teste es",
+	information: "Information",
+	success: "Erfolg",
+	redirect: "Umleitung",
+	error: "Fehler",
+	show: "Zeige ${1}",
+	hide: "Verstecke ${1}",
+	available_items: "Verfügbare Elemente",
+	required_scopes: "Erforderliche Scopes",
+	properties: "Eigenschaften",
+	or: "oder",
+	and: "und",
+	possible_values: "Mögliche Werte"
+};
+
+//#endregion
+//#region src/translations/en.ts
+const en = {
+	required: "Required",
+	deprecated: "Deprecated",
+	deprecated_and_sunset_on: "This operation is deprecated and will be sunset on ${1}.",
+	stability_experimental: "Experimental",
+	stability_alpha: "Alpha",
+	stability_beta: "Beta",
+	discriminator: "Discriminator",
+	copy_to_clipboard: "Copy to clipboard",
+	copied: "Copied",
+	no_content: "No content",
+	unresolved_reference: "Unresolved reference",
+	circular_reference: "Circular reference",
+	read_only: "Read-only",
+	write_only: "Write-only",
+	optional: "Optional",
+	min: "Min",
+	max: "Max",
+	nullable: "Nullable",
+	body: "Body",
+	payload: "Payload",
+	headers: "Headers",
+	header: "Header",
+	authorizations: "Authorizations",
+	responses: "Responses",
+	response: "Response",
+	path_parameters: "Path parameters",
+	query_parameters: "Query parameters",
+	header_parameters: "Header parameters",
+	attributes: "Attributes",
+	test_it: "Test it",
+	information: "Information",
+	success: "Success",
+	redirect: "Redirect",
+	error: "Error",
+	show: "Show ${1}",
+	hide: "Hide ${1}",
+	available_items: "Available items",
+	required_scopes: "Required scopes",
+	possible_values: "Possible values",
+	properties: "Properties",
+	or: "or",
+	and: "and"
+};
+
+//#endregion
+//#region src/translations/es.ts
+const es = {
+	required: "Requerido",
+	deprecated: "Obsoleto",
+	deprecated_and_sunset_on: "Esta operación está obsoleta y se retirará el ${1}.",
+	stability_experimental: "Experimental",
+	stability_alpha: "Alfa",
+	stability_beta: "Beta",
+	discriminator: "Discriminador",
+	copy_to_clipboard: "Copiar al portapapeles",
+	copied: "Copiado",
+	no_content: "Sin contenido",
+	unresolved_reference: "Referencia no resuelta",
+	circular_reference: "Referencia circular",
+	read_only: "Solo lectura",
+	write_only: "Solo escritura",
+	optional: "Opcional",
+	min: "Mín",
+	max: "Máx",
+	nullable: "Nulo",
+	body: "Cuerpo",
+	payload: "Caga útil",
+	headers: "Headers",
+	header: "Header",
+	authorizations: "Autorizaciones",
+	responses: "Respuestas",
+	response: "Respuesta",
+	path_parameters: "Parámetros de ruta",
+	query_parameters: "Parámetros de consulta",
+	header_parameters: "Parámetros de encabezado",
+	attributes: "Atributos",
+	test_it: "Pruébalo",
+	information: "Información",
+	success: "Éxito",
+	redirect: "Redirección",
+	error: "Error",
+	show: "Mostrar ${1}",
+	hide: "Ocultar ${1}",
+	available_items: "Elementos disponibles",
+	required_scopes: "Scopes requeridos",
+	properties: "Propiedades",
+	or: "o",
+	and: "y",
+	possible_values: "Valores posibles"
+};
+
+//#endregion
+//#region src/translations/fr.ts
+const fr = {
+	required: "Requis",
+	deprecated: "Obsolète",
+	deprecated_and_sunset_on: "Cette opération est obsolète et sera supprimée le ${1}.",
+	stability_experimental: "Expérimental",
+	stability_alpha: "Alpha",
+	stability_beta: "Bêta",
+	discriminator: "Discriminateur",
+	copy_to_clipboard: "Copier dans le presse-papiers",
+	copied: "Copié",
+	no_content: "Aucun contenu",
+	unresolved_reference: "Référence non résolue",
+	circular_reference: "Référence circulaire",
+	read_only: "Lecture seule",
+	write_only: "Écriture seule",
+	optional: "Optionnel",
+	min: "Min",
+	max: "Max",
+	nullable: "Nullable",
+	body: "Corps",
+	payload: "Charge utile",
+	headers: "Headers",
+	header: "Header",
+	authorizations: "Autorisations",
+	responses: "Réponses",
+	response: "Réponse",
+	path_parameters: "Paramètres de chemin",
+	query_parameters: "Paramètres de requête",
+	header_parameters: "Paramètres d'en-tête",
+	attributes: "Attributs",
+	test_it: "Tester",
+	information: "Information",
+	success: "Succès",
+	redirect: "Redirection",
+	error: "Erreur",
+	show: "Afficher ${1}",
+	hide: "Masquer ${1}",
+	available_items: "Éléments disponibles",
+	required_scopes: "Scopes requis",
+	properties: "Propriétés",
+	or: "ou",
+	and: "et",
+	possible_values: "Valeurs possibles"
+};
+
+//#endregion
+//#region src/translations/ja.ts
+const ja = {
+	required: "必須",
+	deprecated: "非推奨",
+	deprecated_and_sunset_on: "この操作は非推奨であり、${1}に廃止されます。",
+	stability_experimental: "実験的",
+	stability_alpha: "アルファ",
+	stability_beta: "ベータ",
+	discriminator: "識別子",
+	copy_to_clipboard: "クリップボードにコピー",
+	copied: "コピー済み",
+	no_content: "コンテンツなし",
+	unresolved_reference: "未解決の参照",
+	circular_reference: "循環参照",
+	read_only: "読み取り専用",
+	write_only: "書き込み専用",
+	optional: "オプション",
+	min: "最小",
+	max: "最大",
+	nullable: "ヌル許容",
+	body: "本文",
+	payload: "ペイロード",
+	headers: "ヘッダー",
+	header: "ヘッダー",
+	authorizations: "認可",
+	responses: "レスポンス",
+	response: "レスポンス",
+	path_parameters: "パスパラメータ",
+	query_parameters: "クエリパラメータ",
+	header_parameters: "ヘッダーパラメータ",
+	attributes: "属性",
+	test_it: "テストする",
+	information: "情報",
+	success: "成功",
+	redirect: "リダイレクト",
+	error: "エラー",
+	show: "${1}を表示",
+	hide: "${1}を非表示",
+	available_items: "利用可能なアイテム",
+	required_scopes: "必須スコープ",
+	properties: "プロパティ",
+	or: "または",
+	and: "かつ",
+	possible_values: "可能な値"
+};
+
+//#endregion
+//#region src/translations/nl.ts
+const nl = {
+	required: "Vereist",
+	deprecated: "Verouderd",
+	deprecated_and_sunset_on: "Deze bewerking is verouderd en wordt op ${1} beëindigd.",
+	stability_experimental: "Experimenteel",
+	stability_alpha: "Alfa",
+	stability_beta: "Bèta",
+	discriminator: "Discriminator",
+	copy_to_clipboard: "Kopiëren naar klembord",
+	copied: "Gekopieerd",
+	no_content: "Geen inhoud",
+	unresolved_reference: "Onopgeloste verwijzing",
+	circular_reference: "Circulaire verwijzing",
+	read_only: "Alleen lezen",
+	write_only: "Alleen schrijven",
+	optional: "Optioneel",
+	min: "Min",
+	max: "Max",
+	nullable: "Null toegestaan",
+	body: "Body",
+	payload: "Payload",
+	headers: "Headers",
+	header: "Header",
+	authorizations: "Autorisaties",
+	responses: "Reacties",
+	response: "Reactie",
+	path_parameters: "Padparameters",
+	query_parameters: "Queryparameters",
+	header_parameters: "Headerparameters",
+	attributes: "Attributen",
+	test_it: "Test het",
+	information: "Informatie",
+	success: "Succes",
+	redirect: "Omleiding",
+	error: "Fout",
+	show: "Toon ${1}",
+	hide: "Verberg ${1}",
+	available_items: "Beschikbare items",
+	required_scopes: "Vereiste scopes",
+	properties: "Eigenschappen",
+	or: "of",
+	and: "en",
+	possible_values: "Mogelijke waarden"
+};
+
+//#endregion
+//#region src/translations/no.ts
+const no = {
+	required: "Påkrevd",
+	deprecated: "Foreldet",
+	deprecated_and_sunset_on: "Denne operasjonen er foreldet og vil bli avviklet den ${1}.",
+	stability_experimental: "Eksperimentell",
+	stability_alpha: "Alfa",
+	stability_beta: "Beta",
+	discriminator: "Diskriminator",
+	copy_to_clipboard: "Kopier til utklippstavle",
+	copied: "Kopiert",
+	no_content: "Ingen innhold",
+	unresolved_reference: "Uavklart referanse",
+	circular_reference: "Sirkulær referanse",
+	read_only: "Skrivebeskyttet",
+	write_only: "Kun skriving",
+	optional: "Valgfri",
+	min: "Min",
+	max: "Maks",
+	nullable: "Kan være null",
+	body: "Brødtekst",
+	payload: "Nyttelast",
+	headers: "Headers",
+	header: "Header",
+	authorizations: "Autorisasjoner",
+	responses: "Responser",
+	response: "Respons",
+	path_parameters: "Sti-parametere",
+	query_parameters: "Forespørselsparametere",
+	header_parameters: "Header-parametere",
+	attributes: "Attributter",
+	test_it: "Test det",
+	information: "Informasjon",
+	success: "Suksess",
+	redirect: "Viderekobling",
+	error: "Feil",
+	show: "Vis ${1}",
+	hide: "Skjul ${1}",
+	available_items: "Tilgjengelige elementer",
+	required_scopes: "Påkrevde scopes",
+	properties: "Egenskaper",
+	or: "eller",
+	and: "og",
+	possible_values: "Mulige verdier"
+};
+
+//#endregion
+//#region src/translations/pt-br.ts
+const pt_br = {
+	required: "Obrigatório",
+	deprecated: "Obsoleto",
+	deprecated_and_sunset_on: "Esta operação está obsoleta e será descontinuada em ${1}.",
+	stability_experimental: "Experimental",
+	stability_alpha: "Alfa",
+	stability_beta: "Beta",
+	discriminator: "Discriminador",
+	copy_to_clipboard: "Copiar para a área de transferência",
+	copied: "Copiado",
+	no_content: "Sem conteúdo",
+	unresolved_reference: "Referência não resolvida",
+	circular_reference: "Referência circular",
+	read_only: "Somente leitura",
+	write_only: "Somente escrita",
+	optional: "Opcional",
+	min: "Mín",
+	max: "Máx",
+	nullable: "Nulo",
+	body: "Corpo",
+	payload: "Carga útil",
+	headers: "Headers",
+	header: "Header",
+	authorizations: "Autorizações",
+	responses: "Respostas",
+	response: "Resposta",
+	path_parameters: "Parâmetros de rota",
+	query_parameters: "Parâmetros de consulta",
+	header_parameters: "Parâmetros de cabeçalho",
+	attributes: "Atributos",
+	test_it: "Testar",
+	information: "Informação",
+	success: "Sucesso",
+	redirect: "Redirecionamento",
+	error: "Erro",
+	show: "Mostrar ${1}",
+	hide: "Ocultar ${1}",
+	available_items: "Itens disponíveis",
+	required_scopes: "Scopes obrigatórios",
+	properties: "Propriedades",
+	or: "ou",
+	and: "e",
+	possible_values: "Valores possíveis"
+};
+
+//#endregion
+//#region src/translations/zh.ts
+const zh = {
+	required: "必填",
+	deprecated: "已弃用",
+	deprecated_and_sunset_on: "此操作已弃用，将于 ${1} 停止使用。",
+	stability_experimental: "实验性",
+	stability_alpha: "Alpha",
+	stability_beta: "Beta",
+	discriminator: "判别器",
+	copy_to_clipboard: "复制到剪贴板",
+	copied: "已复制",
+	no_content: "无内容",
+	unresolved_reference: "未解析的引用",
+	circular_reference: "循环引用",
+	read_only: "只读",
+	write_only: "只写",
+	optional: "可选",
+	min: "最小值",
+	max: "最大值",
+	nullable: "可为 null",
+	body: "请求体",
+	payload: "有效载荷",
+	headers: "头字段",
+	header: "头部",
+	authorizations: "授权",
+	responses: "响应",
+	response: "响应",
+	path_parameters: "路径参数",
+	query_parameters: "查询参数",
+	header_parameters: "头参数",
+	attributes: "属性",
+	test_it: "测试一下",
+	information: "信息",
+	success: "成功",
+	redirect: "重定向",
+	error: "错误",
+	show: "显示${1}",
+	hide: "隐藏${1}",
+	available_items: "可用项",
+	required_scopes: "必需范围",
+	properties: "属性",
+	or: "或",
+	and: "和",
+	possible_values: "可能的值"
+};
+
+//#endregion
+//#region src/translations/index.ts
+const translations = {
+	en,
+	de,
+	es,
+	fr,
+	ja,
+	nl,
+	no,
+	"pt-br": pt_br,
+	zh
+};
+/**
+* Check if the locale is valid.
+*/
+function checkIsValidLocale(locale) {
+	return Object.prototype.hasOwnProperty.call(translations, locale);
+}
+
+//#endregion
+//#region src/context.ts
+/**
+* Resolve OpenAPI context from the input.
+*/
+function resolveOpenAPIContext(context) {
+	const { locale,...rest } = context;
+	return {
+		...rest,
+		translation: translations[locale ?? "en"]
+	};
+}
+/**
+* Get the client context from the OpenAPI context.
+*/
+function getOpenAPIClientContext(context) {
+	return {
+		translation: context.translation,
+		icons: context.icons,
+		defaultInteractiveOpened: context.defaultInteractiveOpened,
+		blockKey: context.blockKey,
+		id: context.id,
+		$$isClientContext$$: true
+	};
+}
+
+//#endregion
+//#region src/generateSchemaExample.ts
+/**
+* Generate a JSON example from a schema
+*/
+function generateSchemaExample(schema, options) {
+	return getExampleFromSchema$1(schema, {
+		emptyString: "text",
+		...options
+	});
+}
+/**
+* Generate an example for a media type.
+*/
+function generateMediaTypeExamples(mediaType, options) {
+	if (mediaType.example) return [{
+		summary: "default",
+		value: mediaType.example
+	}];
+	if (mediaType.examples) {
+		const { examples } = mediaType;
+		const keys = Object.keys(examples);
+		if (keys.length > 0) return keys.reduce((result, key) => {
+			const example = examples[key];
+			if (!example || checkIsReference(example)) return result;
+			result.push({
+				summary: example.summary || key,
+				value: example.value,
+				description: example.description,
+				externalValue: example.externalValue
+			});
+			return result;
+		}, []);
+	}
+	if (mediaType.schema) return [{
+		summary: "default",
+		value: generateSchemaExample(mediaType.schema, options)
+	}];
+	return [];
+}
+/** Hard limit for rendering circular references */
+const MAX_LEVELS_DEEP = 5;
+const genericExampleValues = {
+	"date-time": (/* @__PURE__ */ new Date()).toISOString(),
+	date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "1970-01-01",
+	email: "name@gmail.com",
+	hostname: "example.com",
+	ipv4: "0.0.0.0",
+	ipv6: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
+	uri: "https://example.com",
+	uuid: "123e4567-e89b-12d3-a456-426614174000",
+	binary: "binary",
+	byte: "Ynl0ZXM=",
+	password: "password",
+	"idn-email": "jane.doe@example.com",
+	"idn-hostname": "example.com",
+	"iri-reference": "/entitiy/1",
+	iri: "https://example.com/entity/123",
+	"json-pointer": "/nested/objects",
+	regex: "/[a-z]/",
+	"relative-json-pointer": "1/nested/objects",
+	time: (/* @__PURE__ */ new Date()).toISOString().split("T")[1]?.split(".")[0] ?? "00:00:00Z",
+	"uri-reference": "../folder",
+	"uri-template": "https://example.com/{id}",
+	"object-id": "6592008029c8c3e4dc76256c"
+};
+/**
+* We can use the `format` to generate some random values.
+*/
+function guessFromFormat(schema, fallback = "") {
+	return genericExampleValues[schema.format] ?? fallback;
+}
+/**
+* This function takes an OpenAPI schema and generates an example from it
+* Forked from : https://github.com/scalar/scalar/blob/main/packages/oas-utils/src/spec-getters/getExampleFromSchema.ts
+*/
+const getExampleFromSchema$1 = (schema, options, level = 0, parentSchema, name, resultCache = /* @__PURE__ */ new WeakMap()) => {
+	function cache(schema$1, result) {
+		if (typeof result !== "object" || result === null) return result;
+		resultCache.set(schema$1, result);
+		return result;
+	}
+	if (resultCache.has(schema)) return resultCache.get(schema);
+	if (level === MAX_LEVELS_DEEP + 1) try {
+		JSON.stringify(schema);
+	} catch {
+		return "[Circular Reference]";
+	}
+	const makeUpRandomData = !!options?.emptyString;
+	if (schema.deprecated || schema.type === "array" && schema.items?.deprecated) return;
+	if (options?.mode === "write" && schema.readOnly || options?.mode === "read" && schema.writeOnly) return;
+	if (schema["x-variable"]) {
+		const value = options?.variables?.[schema["x-variable"]];
+		if (value !== void 0) {
+			if (schema.type === "number" || schema.type === "integer") return Number.parseInt(value, 10);
+			return cache(schema, value);
+		}
+	}
+	if (Array.isArray(schema.examples) && schema.examples.length > 0) return cache(schema, schema.examples[0]);
+	if (schema.example !== void 0) return cache(schema, schema.example);
+	if (schema.default !== void 0 && [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof schema.default)) return cache(schema, schema.default);
+	if (Array.isArray(schema.enum) && schema.enum.length > 0) return cache(schema, schema.enum[0]);
+	if (!(schema.type === "object" || schema.type === "array" || !!schema.allOf?.at?.(0) || !!schema.anyOf?.at?.(0) || !!schema.oneOf?.at?.(0)) && options?.omitEmptyAndOptionalProperties === true) {
+		if (!(schema.required === true || parentSchema?.required === true || parentSchema?.required?.includes(name ?? schema.name))) return;
+	}
+	if (schema.type === "object" || schema.properties !== void 0) {
+		const response = {};
+		if (schema.properties !== void 0) {
+			for (const propertyName in schema.properties) if (Object.prototype.hasOwnProperty.call(schema.properties, propertyName)) {
+				const property = schema.properties[propertyName];
+				const propertyXmlTagName = options?.xml ? property.xml?.name : void 0;
+				response[propertyXmlTagName ?? propertyName] = getExampleFromSchema$1(property, options, level + 1, schema, propertyName, resultCache);
+				if (typeof response[propertyXmlTagName ?? propertyName] === "undefined") delete response[propertyXmlTagName ?? propertyName];
+			}
+		}
+		if (schema.patternProperties !== void 0) {
+			for (const pattern in schema.patternProperties) if (Object.prototype.hasOwnProperty.call(schema.patternProperties, pattern)) {
+				const property = schema.patternProperties[pattern];
+				const exampleKey = pattern;
+				response[exampleKey] = getExampleFromSchema$1(property, options, level + 1, schema, exampleKey, resultCache);
+			}
+		}
+		if (schema.additionalProperties !== void 0) {
+			if (schema.additionalProperties === true || typeof schema.additionalProperties === "object" && !Object.keys(schema.additionalProperties).length) response.ANY_ADDITIONAL_PROPERTY = "anything";
+			else if (schema.additionalProperties !== false) response.ANY_ADDITIONAL_PROPERTY = getExampleFromSchema$1(schema.additionalProperties, options, level + 1, void 0, void 0, resultCache);
+		}
+		if (schema.anyOf !== void 0) Object.assign(response, getExampleFromSchema$1(schema.anyOf[0], options, level + 1, void 0, void 0, resultCache));
+		else if (schema.oneOf !== void 0) Object.assign(response, getExampleFromSchema$1(schema.oneOf[0], options, level + 1, void 0, void 0, resultCache));
+		else if (schema.allOf !== void 0) Object.assign(response, ...schema.allOf.map((item) => getExampleFromSchema$1(item, options, level + 1, schema, void 0, resultCache)).filter((item) => item !== void 0));
+		return cache(schema, response);
+	}
+	if (schema.type === "array" || schema.items !== void 0) {
+		const itemsXmlTagName = schema?.items?.xml?.name;
+		const wrapItems = !!(options?.xml && schema.xml?.wrapped && itemsXmlTagName);
+		if (schema.example !== void 0) return cache(schema, wrapItems ? { [itemsXmlTagName]: schema.example } : schema.example);
+		if (schema.items) {
+			if (schema.items.allOf) {
+				if (schema.items.allOf[0].type === "object") {
+					const mergedExample = getExampleFromSchema$1({
+						type: "object",
+						allOf: schema.items.allOf
+					}, options, level + 1, schema, void 0, resultCache);
+					return cache(schema, wrapItems ? [{ [itemsXmlTagName]: mergedExample }] : [mergedExample]);
+				}
+				const examples = schema.items.allOf.map((item) => getExampleFromSchema$1(item, options, level + 1, schema, void 0, resultCache)).filter((item) => item !== void 0);
+				return cache(schema, wrapItems ? examples.map((example) => ({ [itemsXmlTagName]: example })) : examples);
+			}
+			for (const rule of ["anyOf", "oneOf"]) {
+				if (!schema.items[rule]) continue;
+				const exampleFromRule = schema.items[rule].slice(0, 1).map((item) => getExampleFromSchema$1(item, options, level + 1, schema, void 0, resultCache)).filter((item) => item !== void 0);
+				return cache(schema, wrapItems ? [{ [itemsXmlTagName]: exampleFromRule }] : exampleFromRule);
+			}
+		}
+		if (schema.items?.type) {
+			const exampleFromSchema = getExampleFromSchema$1(schema.items, options, level + 1, void 0, void 0, resultCache);
+			return wrapItems ? [{ [itemsXmlTagName]: exampleFromSchema }] : [exampleFromSchema];
+		}
+		return [];
+	}
+	const exampleValues = {
+		string: makeUpRandomData ? guessFromFormat(schema, options?.emptyString) : "",
+		boolean: true,
+		integer: schema.min ?? 1,
+		number: schema.min ?? 1,
+		array: []
+	};
+	if (schema.type !== void 0 && exampleValues[schema.type] !== void 0) return cache(schema, exampleValues[schema.type]);
+	const discriminateSchema = schema.oneOf || schema.anyOf;
+	if (Array.isArray(discriminateSchema) && discriminateSchema.length > 0) {
+		const firstOneOfItem = discriminateSchema[0];
+		return getExampleFromSchema$1(firstOneOfItem, options, level + 1, void 0, void 0, resultCache);
+	}
+	if (Array.isArray(schema.allOf)) {
+		let example = null;
+		schema.allOf.forEach((allOfItem) => {
+			const newExample = getExampleFromSchema$1(allOfItem, options, level + 1, void 0, void 0, resultCache);
+			example = typeof newExample === "object" && typeof example === "object" ? {
+				...example ?? {},
+				...newExample
+			} : Array.isArray(newExample) && Array.isArray(example) ? [...example ?? {}, ...newExample] : newExample;
+		});
+		return cache(schema, example);
+	}
+	if (Array.isArray(schema.type)) {
+		if (schema.type.includes("null")) return null;
+		const exampleValue = exampleValues[schema.type[0]];
+		if (exampleValue !== void 0) return cache(schema, exampleValue);
+	}
+	return null;
+};
+
+//#endregion
+//#region src/util/example.tsx
+/**
+* Generate an example from a reference object.
+*/
+function getExampleFromReference(ref, context) {
+	return {
+		summary: tString(context.translation, "unresolved_reference"),
+		value: { $ref: ref.$ref }
+	};
+}
+/**
+* Get examples from a media type object.
+*/
+function getExamplesFromMediaTypeObject(args) {
+	const { mediaTypeObject, mediaType, context } = args;
+	if (mediaTypeObject.examples) return Object.entries(mediaTypeObject.examples).map(([key, example]) => {
+		return {
+			key,
+			example: checkIsReference(example) ? getExampleFromReference(example, context) : example
+		};
+	});
+	if (mediaTypeObject.example) return [{
+		key: "default",
+		example: { value: mediaTypeObject.example }
+	}];
+	if (mediaTypeObject.schema) {
+		if (mediaType === "application/xml") return [{
+			key: "default",
+			example: { value: { [mediaTypeObject.schema.xml?.name ?? "object"]: generateSchemaExample(mediaTypeObject.schema, {
+				xml: mediaType === "application/xml",
+				mode: "read"
+			}) } }
+		}];
+		return [{
+			key: "default",
+			example: { value: generateSchemaExample(mediaTypeObject.schema, { mode: "read" }) }
+		}];
+	}
+	return [];
+}
+/**
+* Get example from a schema object.
+*/
+function getExampleFromSchema(args) {
+	const { schema } = args;
+	if (schema.example) return { value: schema.example };
+	return { value: generateSchemaExample(schema, { mode: "read" }) };
+}
+/**
+* Get the examples from a media type object.
+*/
+function getExamples(props) {
+	const { mediaTypeObject, mediaType, context } = props;
+	const examples = getExamplesFromMediaTypeObject({
+		mediaTypeObject,
+		mediaType,
+		context
+	});
+	const syntax = getSyntaxFromMediaType(mediaType);
+	return examples.map((example) => {
+		return {
+			key: example.key,
+			label: example.example.summary || example.key,
+			body: <OpenAPIExample example={example.example} context={props.context} syntax={syntax} />
+		};
+	});
+}
+/**
+* Get the syntax from a media type.
+*/
+function getSyntaxFromMediaType(mediaType) {
+	if (mediaType.includes("json")) return "json";
+	if (mediaType.includes("yaml")) return "yaml";
+	if (mediaType === "application/xml") return "xml";
+	return "text";
+}
+
+//#endregion
+//#region src/schemas/OpenAPISchemaItem.tsx
+function OpenAPISchemaItem(props) {
+	const { schema, context, name } = props;
+	return <OpenAPIDisclosure className="openapi-schemas-disclosure" key={name} icon={context.icons.plus} header={name} label={(isExpanded) => getDisclosureLabel({
+		schema,
+		isExpanded,
+		context
+	})}>
+            <Section className="openapi-section-schemas">
+                <SectionBody>
+                    <OpenAPIRootSchema schema={schema} context={context} />
+                </SectionBody>
+            </Section>
+        </OpenAPIDisclosure>;
+}
+
+//#endregion
+//#region src/schemas/OpenAPISchemas.tsx
+/**
+* OpenAPI Schemas component.
+*/
+function OpenAPISchemas(props) {
+	const { schemas, context: contextInput, grouped, className } = props;
+	const firstSchema = schemas[0];
+	if (!firstSchema) return null;
+	const context = resolveOpenAPIContext(contextInput);
+	const clientContext = getOpenAPIClientContext(context);
+	if (schemas.length === 1 && !grouped) {
+		const title = `The ${firstSchema.name} object`;
+		return <div className={clsx("openapi-schemas", className)}>
+                <div className="openapi-summary" id={context.id}>
+                    {context.renderHeading({
+			title,
+			deprecated: Boolean(firstSchema.schema.deprecated),
+			stability: firstSchema.schema["x-stability"]
+		})}
+                </div>
+                <div className="openapi-columns">
+                    <div className="openapi-column-spec">
+                        <StaticSection className="openapi-parameters" header={t(context.translation, "attributes")}>
+                            <OpenAPIRootSchema schema={firstSchema.schema} context={clientContext} />
+                        </StaticSection>
+                    </div>
+                    <div className="openapi-column-preview">
+                        <div className="openapi-column-preview-body">
+                            <div className="openapi-panel">
+                                <h4 className="openapi-panel-heading">{title}</h4>
+                                <div className="openapi-panel-body">
+                                    <OpenAPIExample example={getExampleFromSchema({ schema: firstSchema.schema })} context={context} syntax="json" />
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>;
+	}
+	return <div className={clsx("openapi-schemas", className)}>
+            {schemas.map(({ name, schema }) => {
+		return <OpenAPISchemaItem key={name} name={name} context={clientContext} schema={schema} />;
+	})}
+        </div>;
+}
+
+//#endregion
+//#region src/dereference.ts
+const dereferenceCache = /* @__PURE__ */ new WeakMap();
+/**
+* Memoized version of `dereferenceSchema`.
+*/
+function dereferenceFilesystem(filesystem) {
+	if (dereferenceCache.has(filesystem)) return dereferenceCache.get(filesystem);
+	const promise = baseDereferenceFilesystem(filesystem);
+	dereferenceCache.set(filesystem, promise);
+	return promise;
+}
+/**
+* Dereference an OpenAPI schema.
+*/
+async function baseDereferenceFilesystem(filesystem) {
+	const result = await dereference(filesystem);
+	if (!result.schema) throw new Error("Failed to dereference OpenAPI document");
+	return result.schema;
+}
+
+//#endregion
+//#region src/schemas/resolveOpenAPISchemas.ts
+/**
+* Resolve an OpenAPI schemas from a file and compile it to a more usable format.
+* Schemas are extracted from the OpenAPI components.schemas
+*/
+async function resolveOpenAPISchemas(filesystem, options) {
+	const { schemas: selectedSchemas } = options;
+	const schemas = filterSelectedOpenAPISchemas(await dereferenceFilesystem(filesystem), selectedSchemas);
+	if (schemas.length === 0) return null;
+	return { schemas };
+}
+
+//#endregion
+//#region src/getOrCreateStoreByKey.ts
+const createStateStore = (initial) => {
+	return createStore()((set) => ({
+		key: initial ?? null,
+		setKey: (key) => {
+			set(() => ({ key }));
+		}
+	}));
+};
+const defaultStores = /* @__PURE__ */ new Map();
+const createStateStoreFactory = (stores) => {
+	return (storeKey, initialKey) => {
+		if (!stores.has(storeKey)) stores.set(storeKey, createStateStore(initialKey));
+		return stores.get(storeKey);
+	};
+};
+const getOrCreateStoreByKey = createStateStoreFactory(defaultStores);
+
+//#endregion
+//#region src/OpenAPISelect.tsx
+function useSelectState(stateKey = "select-state", initialKey = "default") {
+	const store = useStore(getOrCreateStoreByKey(stateKey, initialKey));
+	return {
+		key: store.key,
+		setKey: useCallback((key) => store.setKey(key), [store.setKey])
+	};
+}
+function OpenAPISelect(props) {
+	const { icon = "▼", items, children, className, placement, stateKey, selectedKey, onSelectionChange } = props;
+	const state = useSelectState(stateKey, items[0]?.key);
+	const selected = items.find((item) => item.key === state.key) || items[0];
+	return <Select aria-label="OpenAPI Select" {...props} selectedKey={selectedKey || selected?.key} onSelectionChange={(key) => {
+		onSelectionChange?.(key);
+		state.setKey(key);
+	}} className={clsx("openapi-select", className)}>
+            <Button>
+                <SelectValue />
+                {icon}
+            </Button>
+            <Popover placement={placement} className="openapi-select-popover">
+                <ListBox className="openapi-select-listbox" items={items}>
+                    {children}
+                </ListBox>
+            </Popover>
+        </Select>;
+}
+function OpenAPISelectItem(props) {
+	return <ListBoxItem {...props} className={({ isFocused, isSelected }) => clsx("openapi-select-item", {
+		"openapi-select-item-focused": isFocused,
+		"openapi-select-item-selected": isSelected
+	})} />;
+}
+
+//#endregion
+//#region src/OpenAPICodeSampleInteractive.tsx
+function OpenAPIMediaTypeExamplesSelector(props) {
+	const { method, path, renderers, selectIcon, blockKey } = props;
+	if (!renderers[0]) throw new Error("No renderers provided");
+	const stateKey = createStateKey("request-body-media-type", blockKey);
+	const state = useSelectState(stateKey, renderers[0].mediaType);
+	const selected = renderers.find((r) => r.mediaType === state.key) || renderers[0];
+	return <div className="openapi-codesample-selectors">
+            <MediaTypeSelector selectIcon={selectIcon} stateKey={stateKey} renderers={renderers} />
+            <ExamplesSelector selectIcon={selectIcon} method={method} path={path} renderer={selected} />
+        </div>;
+}
+function MediaTypeSelector(props) {
+	const { renderers, stateKey, selectIcon } = props;
+	if (renderers.length < 2) return null;
+	const items = renderers.map((renderer) => ({
+		key: renderer.mediaType,
+		label: renderer.mediaType
+	}));
+	return <OpenAPISelect className={clsx("openapi-select")} items={renderers.map((renderer) => ({
+		key: renderer.mediaType,
+		label: renderer.mediaType
+	}))} icon={selectIcon} stateKey={stateKey} placement="bottom start">
+            {items.map((item) => <OpenAPISelectItem key={item.key} id={item.key} value={item}>
+                    {item.label}
+                </OpenAPISelectItem>)}
+        </OpenAPISelect>;
+}
+function ExamplesSelector(props) {
+	const { method, path, renderer, selectIcon } = props;
+	if (renderer.examples.length < 2) return null;
+	const items = renderer.examples.map((example, index) => ({
+		key: index,
+		label: example.example.summary || `Example ${index + 1}`
+	}));
+	return <OpenAPISelect items={items} icon={selectIcon} stateKey={`media-type-sample-${renderer.mediaType}-${method}-${path}`} placement="bottom start">
+            {items.map((item) => <OpenAPISelectItem key={item.key} id={item.key} value={item}>
+                    {item.label}
+                </OpenAPISelectItem>)}
+        </OpenAPISelect>;
+}
+function OpenAPIMediaTypeExamplesBody(props) {
+	const { renderers, method, path, blockKey } = props;
+	if (!renderers[0]) throw new Error("No renderers provided");
+	const mediaTypeState = useSelectState(createStateKey("request-body-media-type", blockKey), renderers[0].mediaType);
+	const selected = renderers.find((r) => r.mediaType === mediaTypeState.key) ?? renderers[0];
+	if (selected.examples.length === 0) return selected.element;
+	return <ExamplesBody method={method} path={path} renderer={selected} />;
+}
+function ExamplesBody(props) {
+	const { method, path, renderer } = props;
+	const exampleState = useSelectState(`media-type-sample-${renderer.mediaType}-${method}-${path}`, renderer.mediaType);
+	const example = renderer.examples[Number(exampleState.key)] ?? renderer.examples[0];
+	if (!example) throw new Error(`No example found for key ${exampleState.key}`);
+	return example.element;
+}
+
+//#endregion
+//#region src/util/server.ts
+/**
+* Get the default URL for the server.
+*/
+function getDefaultServerURL(servers) {
+	const server = servers[0];
+	if (!server) return "";
+	return interpolateServerURL(server);
+}
+/**
+* Interpolate the server URL with the default values of the variables.
+*/
+function interpolateServerURL(server) {
+	return parseServerURL(server?.url ?? "").map((part) => {
+		if (part.kind === "text") return part.text;
+		return server.variables?.[part.name]?.default ?? `{${part.name}}`;
+	}).join("");
+}
+function parseServerURL(url) {
+	const parts = url.split(/{([^}]+)}/g);
+	const result = [];
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (!part) continue;
+		if (i % 2 === 0) result.push({
+			kind: "text",
+			text: part
+		});
+		else result.push({
+			kind: "variable",
+			name: part
+		});
+	}
+	return result;
+}
+
+//#endregion
+//#region src/OpenAPIPath.tsx
+/**
+* Display the path of an operation.
+*/
+function OpenAPIPath(props) {
+	const { data, context, withServer = true, canCopy = true } = props;
+	const { method, path, operation } = data;
+	const server = getDefaultServerURL(data.servers);
+	const formattedPath = formatPath(path);
+	const element = (() => {
+		return <>
+                {withServer ? <span className="openapi-path-server">{server}</span> : null}
+                {formattedPath}
+            </>;
+	})();
+	return <div className="openapi-path">
+            <div className={`openapi-method openapi-method-${method}`}>{method}</div>
+
+            <OpenAPICopyButton value={`${withServer ? server : ""}${path}`} className="openapi-path-title" data-deprecated={operation.deprecated} isDisabled={!canCopy} context={getOpenAPIClientContext(context)}>
+                {element}
+            </OpenAPICopyButton>
+        </div>;
+}
+/**
+* Format the path by wrapping placeholders in <span> tags.
+*/
+function formatPath(path) {
+	const regex = /\{\s*(\w+)\s*\}|:\w+/g;
+	const parts = [];
+	let lastIndex = 0;
+	path.replace(regex, (match, _, offset) => {
+		if (offset > lastIndex) parts.push(path.slice(lastIndex, offset));
+		parts.push(<span key={`offset-${offset}`} className="openapi-path-variable">
+                {match}
+            </span>);
+		lastIndex = offset + match.length;
+		return match;
+	});
+	if (lastIndex < path.length) parts.push(path.slice(lastIndex));
+	return parts.map((part, index) => {
+		if (typeof part === "string") return <span key={`part-${index}`}>{part}</span>;
+		return part;
+	});
+}
+
+//#endregion
+//#region src/OpenAPICodeSampleSelector.tsx
+function useCodeSampleState(initialKey = "default") {
+	const store = useStore(getOrCreateStoreByKey("codesample", initialKey));
+	return {
+		key: store.key,
+		setKey: useCallback((key) => store.setKey(key), [store.setKey])
+	};
+}
+function OpenAPICodeSampleHeader(props) {
+	const { data, items, selectIcon, context } = props;
+	return <>
+            <OpenAPIPath context={context} canCopy={false} withServer={false} data={data} />
+            {items.length > 1 ? <OpenAPISelect icon={selectIcon} items={items} stateKey="codesample" placement="bottom end">
+                    {items.map((item) => <OpenAPISelectItem key={item.key} id={item.key} value={item}>
+                            {item.label}
+                        </OpenAPISelectItem>)}
+                </OpenAPISelect> : items[0] ? <span className="openapi-codesample-label">{items[0].label}</span> : null}
+        </>;
+}
+function OpenAPICodeSampleBody(props) {
+	const { items, data, selectIcon, context } = props;
+	if (!items[0]) throw new Error("No items provided");
+	const state = useCodeSampleState(items[0]?.key);
+	const selected = items.find((item) => item.key === state.key) || items[0];
+	if (!selected) return null;
+	return <StaticSection header={<OpenAPICodeSampleHeader context={context} selectIcon={selectIcon} data={data} items={items} />} className="openapi-codesample">
+            <div id={selected.key} className="openapi-codesample-panel">
+                {selected.body ? selected.body : null}
+                {selected.footer ? selected.footer : null}
+            </div>
+        </StaticSection>;
+}
+
+//#endregion
+//#region ../../node_modules/react-dom/cjs/react-dom.production.js
+var require_react_dom_production = /* @__PURE__ */ __commonJS({ "../../node_modules/react-dom/cjs/react-dom.production.js": ((exports) => {
+	var React$2 = __require("react");
+	function formatProdErrorMessage(code) {
+		var url = "https://react.dev/errors/" + code;
+		if (1 < arguments.length) {
+			url += "?args[]=" + encodeURIComponent(arguments[1]);
+			for (var i = 2; i < arguments.length; i++) url += "&args[]=" + encodeURIComponent(arguments[i]);
+		}
+		return "Minified React error #" + code + "; visit " + url + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+	}
+	function noop() {}
+	var Internals = {
+		d: {
+			f: noop,
+			r: function() {
+				throw Error(formatProdErrorMessage(522));
+			},
+			D: noop,
+			C: noop,
+			L: noop,
+			m: noop,
+			X: noop,
+			S: noop,
+			M: noop
+		},
+		p: 0,
+		findDOMNode: null
+	}, REACT_PORTAL_TYPE = Symbol.for("react.portal");
+	function createPortal$1(children, containerInfo, implementation) {
+		var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+		return {
+			$$typeof: REACT_PORTAL_TYPE,
+			key: null == key ? null : "" + key,
+			children,
+			containerInfo,
+			implementation
+		};
+	}
+	var ReactSharedInternals = React$2.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+	exports.createPortal = function(children, container) {
+		var key = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
+		if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType) throw Error(formatProdErrorMessage(299));
+		return createPortal$1(children, container, null, key);
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/react-dom/cjs/react-dom.development.js
+var require_react_dom_development = /* @__PURE__ */ __commonJS({ "../../node_modules/react-dom/cjs/react-dom.development.js": ((exports) => {
+	"production" !== process.env.NODE_ENV && (function() {
+		function noop$1() {}
+		function testStringCoercion(value) {
+			return "" + value;
+		}
+		function createPortal$1$1(children, containerInfo, implementation) {
+			var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+			try {
+				testStringCoercion(key);
+				var JSCompiler_inline_result = !1;
+			} catch (e) {
+				JSCompiler_inline_result = !0;
+			}
+			JSCompiler_inline_result && (console.error("The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", "function" === typeof Symbol && Symbol.toStringTag && key[Symbol.toStringTag] || key.constructor.name || "Object"), testStringCoercion(key));
+			return {
+				$$typeof: REACT_PORTAL_TYPE$1,
+				key: null == key ? null : "" + key,
+				children,
+				containerInfo,
+				implementation
+			};
+		}
+		function getCrossOriginStringAs(as, input) {
+			if ("font" === as) return "";
+			if ("string" === typeof input) return "use-credentials" === input ? input : "";
+		}
+		function getValueDescriptorExpectingObjectForWarning(thing) {
+			return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : "something with type \"" + typeof thing + "\"";
+		}
+		function getValueDescriptorExpectingEnumForWarning(thing) {
+			return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : "string" === typeof thing ? JSON.stringify(thing) : "number" === typeof thing ? "`" + thing + "`" : "something with type \"" + typeof thing + "\"";
+		}
+		function resolveDispatcher() {
+			var dispatcher = ReactSharedInternals$1.H;
+			null === dispatcher && console.error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.");
+			return dispatcher;
+		}
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+		var React$3 = __require("react"), Internals$1 = {
+			d: {
+				f: noop$1,
+				r: function() {
+					throw Error("Invalid form element. requestFormReset must be passed a form that was rendered by React.");
+				},
+				D: noop$1,
+				C: noop$1,
+				L: noop$1,
+				m: noop$1,
+				X: noop$1,
+				S: noop$1,
+				M: noop$1
+			},
+			p: 0,
+			findDOMNode: null
+		}, REACT_PORTAL_TYPE$1 = Symbol.for("react.portal"), ReactSharedInternals$1 = React$3.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+		"function" === typeof Map && null != Map.prototype && "function" === typeof Map.prototype.forEach && "function" === typeof Set && null != Set.prototype && "function" === typeof Set.prototype.clear && "function" === typeof Set.prototype.forEach || console.error("React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");
+		exports.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals$1;
+		exports.createPortal = function(children, container) {
+			var key = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
+			if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType) throw Error("Target container is not a DOM element.");
+			return createPortal$1$1(children, container, null, key);
+		};
+		exports.flushSync = function(fn) {
+			var previousTransition = ReactSharedInternals$1.T, previousUpdatePriority = Internals$1.p;
+			try {
+				if (ReactSharedInternals$1.T = null, Internals$1.p = 2, fn) return fn();
+			} finally {
+				ReactSharedInternals$1.T = previousTransition, Internals$1.p = previousUpdatePriority, Internals$1.d.f() && console.error("flushSync was called from inside a lifecycle method. React cannot flush when React is already rendering. Consider moving this call to a scheduler task or micro task.");
+			}
+		};
+		exports.preconnect = function(href, options) {
+			"string" === typeof href && href ? null != options && "object" !== typeof options ? console.error("ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.", getValueDescriptorExpectingEnumForWarning(options)) : null != options && "string" !== typeof options.crossOrigin && console.error("ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.", getValueDescriptorExpectingObjectForWarning(options.crossOrigin)) : console.error("ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.", getValueDescriptorExpectingObjectForWarning(href));
+			"string" === typeof href && (options ? (options = options.crossOrigin, options = "string" === typeof options ? "use-credentials" === options ? options : "" : void 0) : options = null, Internals$1.d.C(href, options));
+		};
+		exports.prefetchDNS = function(href) {
+			if ("string" !== typeof href || !href) console.error("ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.", getValueDescriptorExpectingObjectForWarning(href));
+			else if (1 < arguments.length) {
+				var options = arguments[1];
+				"object" === typeof options && options.hasOwnProperty("crossOrigin") ? console.error("ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.", getValueDescriptorExpectingEnumForWarning(options)) : console.error("ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.", getValueDescriptorExpectingEnumForWarning(options));
+			}
+			"string" === typeof href && Internals$1.d.D(href);
+		};
+		exports.preinit = function(href, options) {
+			"string" === typeof href && href ? null == options || "object" !== typeof options ? console.error("ReactDOM.preinit(): Expected the `options` argument (second) to be an object with an `as` property describing the type of resource to be preinitialized but encountered %s instead.", getValueDescriptorExpectingEnumForWarning(options)) : "style" !== options.as && "script" !== options.as && console.error("ReactDOM.preinit(): Expected the `as` property in the `options` argument (second) to contain a valid value describing the type of resource to be preinitialized but encountered %s instead. Valid values for `as` are \"style\" and \"script\".", getValueDescriptorExpectingEnumForWarning(options.as)) : console.error("ReactDOM.preinit(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.", getValueDescriptorExpectingObjectForWarning(href));
+			if ("string" === typeof href && options && "string" === typeof options.as) {
+				var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin), integrity = "string" === typeof options.integrity ? options.integrity : void 0, fetchPriority = "string" === typeof options.fetchPriority ? options.fetchPriority : void 0;
+				"style" === as ? Internals$1.d.S(href, "string" === typeof options.precedence ? options.precedence : void 0, {
+					crossOrigin,
+					integrity,
+					fetchPriority
+				}) : "script" === as && Internals$1.d.X(href, {
+					crossOrigin,
+					integrity,
+					fetchPriority,
+					nonce: "string" === typeof options.nonce ? options.nonce : void 0
+				});
+			}
+		};
+		exports.preinitModule = function(href, options) {
+			var encountered = "";
+			"string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+			void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "script" !== options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingEnumForWarning(options.as) + ".");
+			if (encountered) console.error("ReactDOM.preinitModule(): Expected up to two arguments, a non-empty `href` string and, optionally, an `options` object with a valid `as` property.%s", encountered);
+			else switch (encountered = options && "string" === typeof options.as ? options.as : "script", encountered) {
+				case "script": break;
+				default: encountered = getValueDescriptorExpectingEnumForWarning(encountered), console.error("ReactDOM.preinitModule(): Currently the only supported \"as\" type for this function is \"script\" but received \"%s\" instead. This warning was generated for `href` \"%s\". In the future other module types will be supported, aligning with the import-attributes proposal. Learn more here: (https://github.com/tc39/proposal-import-attributes)", encountered, href);
+			}
+			if ("string" === typeof href) if ("object" === typeof options && null !== options) {
+				if (null == options.as || "script" === options.as) encountered = getCrossOriginStringAs(options.as, options.crossOrigin), Internals$1.d.M(href, {
+					crossOrigin: encountered,
+					integrity: "string" === typeof options.integrity ? options.integrity : void 0,
+					nonce: "string" === typeof options.nonce ? options.nonce : void 0
+				});
+			} else options ?? Internals$1.d.M(href);
+		};
+		exports.preload = function(href, options) {
+			var encountered = "";
+			"string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+			null == options || "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : "string" === typeof options.as && options.as || (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
+			encountered && console.error("ReactDOM.preload(): Expected two arguments, a non-empty `href` string and an `options` object with an `as` property valid for a `<link rel=\"preload\" as=\"...\" />` tag.%s", encountered);
+			if ("string" === typeof href && "object" === typeof options && null !== options && "string" === typeof options.as) {
+				encountered = options.as;
+				var crossOrigin = getCrossOriginStringAs(encountered, options.crossOrigin);
+				Internals$1.d.L(href, encountered, {
+					crossOrigin,
+					integrity: "string" === typeof options.integrity ? options.integrity : void 0,
+					nonce: "string" === typeof options.nonce ? options.nonce : void 0,
+					type: "string" === typeof options.type ? options.type : void 0,
+					fetchPriority: "string" === typeof options.fetchPriority ? options.fetchPriority : void 0,
+					referrerPolicy: "string" === typeof options.referrerPolicy ? options.referrerPolicy : void 0,
+					imageSrcSet: "string" === typeof options.imageSrcSet ? options.imageSrcSet : void 0,
+					imageSizes: "string" === typeof options.imageSizes ? options.imageSizes : void 0,
+					media: "string" === typeof options.media ? options.media : void 0
+				});
+			}
+		};
+		exports.preloadModule = function(href, options) {
+			var encountered = "";
+			"string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+			void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "string" !== typeof options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
+			encountered && console.error("ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel=\"modulepreload\" as=\"...\" />` tag.%s", encountered);
+			"string" === typeof href && (options ? (encountered = getCrossOriginStringAs(options.as, options.crossOrigin), Internals$1.d.m(href, {
+				as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
+				crossOrigin: encountered,
+				integrity: "string" === typeof options.integrity ? options.integrity : void 0
+			})) : Internals$1.d.m(href));
+		};
+		exports.requestFormReset = function(form) {
+			Internals$1.d.r(form);
+		};
+		exports.unstable_batchedUpdates = function(fn, a) {
+			return fn(a);
+		};
+		exports.useFormState = function(action, initialState, permalink) {
+			return resolveDispatcher().useFormState(action, initialState, permalink);
+		};
+		exports.useFormStatus = function() {
+			return resolveDispatcher().useHostTransitionStatus();
+		};
+		exports.version = "19.1.0";
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	})();
+}) });
+
+//#endregion
+//#region ../../node_modules/react-dom/index.js
+var require_react_dom = /* @__PURE__ */ __commonJS({ "../../node_modules/react-dom/index.js": ((exports, module) => {
+	function checkDCE() {
+		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== "function") return;
+		if (process.env.NODE_ENV !== "production") throw new Error("^_^");
+		try {
+			__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
+		} catch (err) {
+			console.error(err);
+		}
+	}
+	if (process.env.NODE_ENV === "production") {
+		checkDCE();
+		module.exports = require_react_dom_production();
+	} else module.exports = require_react_dom_development();
+}) });
+
+//#endregion
+//#region src/OpenAPIOperationContext.tsx
+var import_react_dom = /* @__PURE__ */ __toESM(require_react_dom());
+const OpenAPIOperationContext = createContext({ onOpenClient: () => {} });
+/**
+* Provider for the OpenAPIOperationContext.
+*/
+function OpenAPIOperationContextProvider(props) {
+	const { children } = props;
+	const onOpenClient = useEventCallback((pointer) => {
+		props.onOpenClient?.(pointer);
+	});
+	const value = useMemo(() => ({ onOpenClient }), [onOpenClient]);
+	return <OpenAPIOperationContext.Provider value={value}>
+            {children}
+        </OpenAPIOperationContext.Provider>;
+}
+/**
+* Hook to access the OpenAPIOperationContext.
+*/
+function useOpenAPIOperationContext() {
+	return useContext(OpenAPIOperationContext);
+}
+
+//#endregion
+//#region src/OpenAPIPrefillContextProvider.tsx
+const OpenAPIPrefillContext = React$1.createContext(null);
+/**
+* Provide context to help prefill dynamic info like visitor data in OpenAPI blocks.
+*/
+function OpenAPIPrefillContextProvider(props) {
+	const { getPrefillInputContextData, children } = props;
+	return <OpenAPIPrefillContext.Provider value={getPrefillInputContextData}>
+            {children}
+        </OpenAPIPrefillContext.Provider>;
+}
+/**
+* Hook to access the prefill context function.
+*/
+function useOpenAPIPrefillContext() {
+	return React$1.useContext(OpenAPIPrefillContext) ?? (() => null);
+}
+
+//#endregion
+//#region src/util/tryit-prefill.ts
+const PREFILL_CUSTOM_PROPERTY = "x-gitbook-prefill";
+/**
+* Resolve the Scalar API client prefill configuration for a given OpenAPI operation.
+*/
+function resolveTryItPrefillForOperation(args) {
+	const { operation: { securities, servers }, prefillInputContext } = args;
+	if (!prefillInputContext) return {};
+	const runtime = new ExpressionRuntime();
+	const resolveTryItPrefillExpression = (expr) => {
+		if (!parseTemplate(expr).length) return;
+		return runtime.evaluateTemplate(expr, prefillInputContext);
+	};
+	const prefillAuth = securities ? resolveTryItPrefillAuthForOperationSecurities({
+		securities,
+		resolveTryItPrefillExpression
+	}) : void 0;
+	const prefillServers = servers ? resolveTryItPrefillServersForOperationServers({
+		servers,
+		resolveTryItPrefillExpression
+	}) : [];
+	return {
+		...prefillAuth ? { authentication: prefillAuth } : {},
+		...prefillServers ? { servers: prefillServers } : {}
+	};
+}
+/**
+* Resolve prefill authentication configuration for the security schemes defined for an operation.
+*/
+function resolveTryItPrefillAuthForOperationSecurities(args) {
+	const { securities, resolveTryItPrefillExpression } = args;
+	const prefillAuthConfig = {};
+	for (const [schemeName, security] of Object.values(securities)) {
+		const tryitPrefillAuthValue = security[PREFILL_CUSTOM_PROPERTY] ? resolveTryItPrefillExpression(security[PREFILL_CUSTOM_PROPERTY]) : void 0;
+		if (!tryitPrefillAuthValue) continue;
+		switch (security.type) {
+			case "http":
+				if (security.scheme?.includes("bearer")) prefillAuthConfig[schemeName] = { token: tryitPrefillAuthValue };
+				else if (security.scheme?.includes("basic") && tryitPrefillAuthValue.includes(":")) {
+					const [username, password] = tryitPrefillAuthValue.split(":", 2);
+					prefillAuthConfig[schemeName] = {
+						username,
+						password
+					};
+				}
+				break;
+			case "apiKey":
+				prefillAuthConfig[schemeName] = {
+					name: security.name,
+					in: security.in,
+					value: tryitPrefillAuthValue
+				};
+				break;
+			case "oauth2":
+			case "openIdConnect": break;
+		}
+	}
+	return Object.keys(prefillAuthConfig).length > 0 ? { securitySchemes: prefillAuthConfig } : void 0;
+}
+/**
+* Resolve prefill server configuration for the servers defined for an operation.
+*/
+function resolveTryItPrefillServersForOperationServers(args) {
+	const { servers, resolveTryItPrefillExpression } = args;
+	const resolvedServers = [];
+	for (const server of servers) {
+		const tryItPrefillServerUrlExpr = server[PREFILL_CUSTOM_PROPERTY];
+		const tryItPrefillServerUrlValue = tryItPrefillServerUrlExpr ? resolveTryItPrefillExpression(tryItPrefillServerUrlExpr) : void 0;
+		const variables = server.variables ? { ...server.variables } : {};
+		if (server.variables) for (const [varName, variable] of Object.entries(server.variables)) {
+			const { [PREFILL_CUSTOM_PROPERTY]: tryItPrefillVarExpr,...variableProps } = variable;
+			const tryItPrefillVarValue = tryItPrefillVarExpr ? resolveTryItPrefillExpression(tryItPrefillVarExpr) : void 0;
+			variables[varName] = {
+				...variableProps,
+				...tryItPrefillVarValue ? { default: String(tryItPrefillVarValue) } : {}
+			};
+		}
+		const hasServerVariables = Object.keys(variables).length > 0;
+		if (server.url && (tryItPrefillServerUrlValue || hasServerVariables)) {
+			const resolvedServer = {
+				url: tryItPrefillServerUrlValue ?? server.url,
+				...server.description ? { description: server.description } : {},
+				...hasServerVariables ? { variables } : {}
+			};
+			resolvedServers.push(resolvedServer);
+		}
+	}
+	return resolvedServers.length > 0 ? resolvedServers : void 0;
+}
+/**
+* Return a X-GITBOOK-PREFILL placeholder based on the prefill custom property in the provided security scheme.
+*/
+function resolvePrefillCodePlaceholderFromSecurityScheme(args) {
+	const { security, defaultPlaceholderValue } = args;
+	const prefillExprParts = extractPrefillExpressionPartsFromSecurityScheme(security);
+	if (prefillExprParts.length === 0) return defaultPlaceholderValue ?? "";
+	return toPrefillCodePlaceholder(templatePartsToExpression(prefillExprParts), defaultPlaceholderValue);
+}
+function extractPrefillExpressionPartsFromSecurityScheme(security) {
+	const expression = security[PREFILL_CUSTOM_PROPERTY];
+	if (!expression || expression.length === 0) return [];
+	return parseTemplate(expression);
+}
+/**
+* Return a server URL with X-GITBOOK-PREFILL placeholders based on the prefill custom properties in the provided security scheme.
+*/
+function resolveURLWithPrefillCodePlaceholdersFromServer(server, defaultServerUrl) {
+	const serverVariables = server.variables ?? {};
+	const variableExprs = {};
+	let hasVariablePrefill = false;
+	for (const [name, variable] of Object.entries(serverVariables ?? {})) if (variable[PREFILL_CUSTOM_PROPERTY]) {
+		hasVariablePrefill = true;
+		variableExprs[name] = `(${templatePartsToExpression(parseTemplate(variable[PREFILL_CUSTOM_PROPERTY]))} ?? '${variable.default ?? ""}')`;
+	} else variableExprs[name] = String(variable.default) ?? "";
+	let interpolatedUrl = server.url ?? "";
+	interpolatedUrl = interpolatedUrl.replace(/{([^}]+)}/g, (_, varName) => {
+		const expr = variableExprs[varName];
+		if (serverVariables[varName]?.[PREFILL_CUSTOM_PROPERTY]) return `\${${expr ?? `'${varName}'`}}`;
+		return expr ?? `{${varName}}`;
+	});
+	const interpolatedUrlTemplate = hasVariablePrefill ? `\`${interpolatedUrl}\`` : interpolatedUrl;
+	const urlLevelExpr = server[PREFILL_CUSTOM_PROPERTY];
+	if (urlLevelExpr) return toPrefillCodePlaceholder(`${templatePartsToExpression(parseTemplate(urlLevelExpr))} ?? ${hasVariablePrefill ? interpolatedUrlTemplate : `'${interpolatedUrlTemplate}'`}`, defaultServerUrl);
+	if (hasVariablePrefill) return toPrefillCodePlaceholder(interpolatedUrlTemplate, defaultServerUrl);
+	return interpolatedUrl;
+}
+function templatePartsToExpression(parts) {
+	return parts.map((part) => {
+		switch (part.type) {
+			case "text": return `"${part.value}"`;
+			case "expression": return part.value;
+			default: return "";
+		}
+	}).join(" + ");
+}
+function toPrefillCodePlaceholder(expression, defaultValue) {
+	return `$$__X-GITBOOK-PREFILL[(${expression})${defaultValue ? ` ?? '${defaultValue}'` : ""}]__$$`;
+}
+
+//#endregion
+//#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 && (0, import_react_dom.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,
+		path
+	}}>
+            <ScalarModalController method={method} path={path} controllerRef={controllerRef} />
+        </ApiClientModalProvider>;
+}
+function ScalarModalController(props) {
+	const { method, path, controllerRef } = props;
+	const openScalarClient = useApiClientModal()?.open;
+	const { onOpenClient: trackClientOpening } = useOpenAPIOperationContext();
+	const openClient = useMemo(() => {
+		if (openScalarClient) return () => {
+			openScalarClient({
+				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
+//#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
+//#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 separator = " \\\n";
+			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 lines.map((line, index) => index > 0 ? indent(line, 2) : line).join(separator);
+		}
+	},
+	{
+		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 body = `--data '${stringifyOpenAPI(body, null, 2).replace(/\\n/g, "\n")}'`;
+		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, "	");
+}
+
+//#endregion
+//#region src/OpenAPICodeSample.tsx
+const CUSTOM_CODE_SAMPLES_KEYS = [
+	"x-custom-examples",
+	"x-code-samples",
+	"x-codeSamples"
+];
+/**
+* Display code samples to execute the operation.
+* It supports the Redocly custom syntax as well (https://redocly.com/docs/api-reference-docs/specification-extensions/x-code-samples/)
+*/
+function OpenAPICodeSample(props) {
+	const { data, context } = props;
+	if (data.operation["x-codeSamples"] === false) return null;
+	const customCodeSamples = getCustomCodeSamples(props);
+	if (data["x-codeSamples"] === false && !customCodeSamples) return null;
+	const samples = customCodeSamples ?? generateCodeSamples(props);
+	if (samples.length === 0) return null;
+	return <OpenAPICodeSampleBody context={getOpenAPIClientContext(context)} data={data} items={samples} selectIcon={context.icons.chevronDown} />;
+}
+/**
+* Generate code samples for the operation.
+*/
+function generateCodeSamples(props) {
+	const { data, context } = props;
+	const searchParams = new URLSearchParams();
+	const headersObject = {};
+	(Array.isArray(data.operation.parameters) ? data.operation.parameters : []).forEach((param) => {
+		if (!param) return;
+		if (param.in === "header" && param.required) {
+			const example = param.schema ? generateSchemaExample(param.schema, { mode: "write" }) : void 0;
+			if (example !== void 0 && param.name) headersObject[param.name] = typeof example !== "string" ? stringifyOpenAPI(example) : example;
+		} else if (param.in === "query" && param.required) {
+			const example = param.schema ? generateSchemaExample(param.schema, { mode: "write" }) : void 0;
+			if (example !== void 0 && param.name) searchParams.append(param.name, String(Array.isArray(example) ? example[0] : example));
+		}
+	});
+	const requestBody = !checkIsReference(data.operation.requestBody) ? data.operation.requestBody : void 0;
+	const defaultServerUrl = getDefaultServerURL(data.servers);
+	let serverUrlPath = defaultServerUrl ? parseHostAndPath(defaultServerUrl).path : "";
+	serverUrlPath = serverUrlPath === "/" ? "" : serverUrlPath;
+	const serverUrlOrigin = (data.servers[0] ? resolveURLWithPrefillCodePlaceholdersFromServer(data.servers[0], defaultServerUrl) : defaultServerUrl).replaceAll(serverUrlPath, "");
+	const path = serverUrlPath + data.path + (searchParams.size ? `?${searchParams.toString()}` : "");
+	const genericHeaders = {
+		...getSecurityHeaders({
+			securityRequirement: data.operation.security,
+			securities: data.securities
+		}),
+		...headersObject
+	};
+	const mediaTypeRendererFactories = Object.entries(requestBody?.content ?? {}).map(([mediaType, mediaTypeObject]) => {
+		return (generator) => {
+			const mediaTypeHeaders = {
+				...genericHeaders,
+				"Content-Type": mediaType
+			};
+			return {
+				mediaType,
+				element: context.renderCodeBlock({
+					code: generator.generate({
+						url: {
+							origin: serverUrlOrigin,
+							path
+						},
+						method: data.method,
+						body: void 0,
+						headers: mediaTypeHeaders
+					}),
+					syntax: generator.syntax
+				}),
+				examples: generateMediaTypeExamples(mediaTypeObject, { mode: "write" }).map((example) => ({
+					example,
+					element: context.renderCodeBlock({
+						code: generator.generate({
+							url: {
+								origin: serverUrlOrigin,
+								path
+							},
+							method: data.method,
+							body: example.value,
+							headers: mediaTypeHeaders
+						}),
+						syntax: generator.syntax
+					})
+				}))
+			};
+		};
+	});
+	return codeSampleGenerators.map((generator) => {
+		if (mediaTypeRendererFactories.length > 0) {
+			const renderers = mediaTypeRendererFactories.map((generate) => generate(generator));
+			return {
+				key: `default-${generator.id}`,
+				label: generator.label,
+				body: <OpenAPIMediaTypeExamplesBody method={data.method} path={data.path} renderers={renderers} blockKey={context.blockKey} />,
+				footer: <OpenAPICodeSampleFooter renderers={renderers} data={data} context={context} />
+			};
+		}
+		return {
+			key: `default-${generator.id}`,
+			label: generator.label,
+			body: context.renderCodeBlock({
+				code: generator.generate({
+					url: {
+						origin: serverUrlOrigin,
+						path
+					},
+					method: data.method,
+					body: void 0,
+					headers: genericHeaders
+				}),
+				syntax: generator.syntax
+			}),
+			footer: <OpenAPICodeSampleFooter data={data} renderers={[]} context={context} />
+		};
+	});
+}
+function OpenAPICodeSampleFooter(props) {
+	const { data, context, renderers } = props;
+	const { method, path, securities, servers } = data;
+	const { specUrl } = context;
+	const hideTryItPanel = data["x-hideTryItPanel"] || data.operation["x-hideTryItPanel"];
+	const hasMultipleMediaTypes = renderers.length > 1 || renderers.some((renderer) => renderer.examples.length > 0);
+	if (hideTryItPanel && !hasMultipleMediaTypes) return null;
+	if (!validateHttpMethod(method)) return null;
+	return <div className="openapi-codesample-footer">
+            {hasMultipleMediaTypes ? <OpenAPIMediaTypeExamplesSelector method={data.method} path={data.path} renderers={renderers} selectIcon={context.icons.chevronDown} blockKey={context.blockKey} /> : <span />}
+            {!hideTryItPanel && <ScalarApiButton context={getOpenAPIClientContext(context)} method={method} path={path} securities={securities} servers={servers} specUrl={specUrl} />}
+        </div>;
+}
+/**
+* Get custom code samples for the operation.
+*/
+function getCustomCodeSamples(props) {
+	const { data, context } = props;
+	let customCodeSamples = null;
+	CUSTOM_CODE_SAMPLES_KEYS.forEach((key) => {
+		const customSamples = data.operation[key];
+		if (customSamples && Array.isArray(customSamples)) customCodeSamples = customSamples.filter((sample) => {
+			return typeof sample.source === "string" && typeof sample.lang === "string";
+		}).map((sample, index) => ({
+			key: `custom-sample-${sample.lang}-${index}`,
+			label: sample.label || sample.lang,
+			body: context.renderCodeBlock({
+				code: sample.source,
+				syntax: sample.lang
+			}),
+			footer: <OpenAPICodeSampleFooter renderers={[]} data={data} context={context} />
+		}));
+	});
+	return customCodeSamples;
+}
+function getSecurityHeaders(args) {
+	const { securityRequirement, securities } = args;
+	const operationSecurityInfo = extractOperationSecurityInfo({
+		securityRequirement,
+		securities
+	});
+	if (operationSecurityInfo.length === 0) return {};
+	const selectedSecurity = operationSecurityInfo.at(0);
+	if (!selectedSecurity) return {};
+	const headers = {};
+	for (const security of selectedSecurity.schemes) switch (security.type) {
+		case "http": {
+			let scheme = security.scheme;
+			const format = resolvePrefillCodePlaceholderFromSecurityScheme({
+				security,
+				defaultPlaceholderValue: scheme?.includes("basic") ? "username:password" : "YOUR_SECRET_TOKEN"
+			});
+			if (scheme?.includes("bearer")) scheme = "Bearer";
+			else if (scheme?.includes("basic")) scheme = "Basic";
+			else if (scheme?.includes("token")) scheme = "Token";
+			headers.Authorization = `${scheme} ${format}`;
+			break;
+		}
+		case "apiKey": {
+			if (security.in !== "header") break;
+			const name = security.name ?? "Authorization";
+			headers[name] = resolvePrefillCodePlaceholderFromSecurityScheme({
+				security,
+				defaultPlaceholderValue: "YOUR_API_KEY"
+			});
+			break;
+		}
+		case "oauth2":
+			headers.Authorization = `Bearer ${resolvePrefillCodePlaceholderFromSecurityScheme({
+				security,
+				defaultPlaceholderValue: "YOUR_OAUTH2_TOKEN"
+			})}`;
+			break;
+		default: break;
+	}
+	return headers;
+}
+function validateHttpMethod(method) {
+	return [
+		"get",
+		"post",
+		"put",
+		"delete",
+		"patch",
+		"head",
+		"options",
+		"trace"
+	].includes(method);
+}
+
+//#endregion
+//#region src/OpenAPIMediaType.tsx
+/**
+* Get the state of the response examples select.
+*/
+function useMediaTypesState(stateKey, initialKey = "default") {
+	return useSelectState(stateKey, initialKey);
+}
+function useMediaTypeExamplesState(stateKey, initialKey = "default") {
+	return useSelectState(stateKey, initialKey);
+}
+function OpenAPIMediaTypeContent(props) {
+	const { stateKey, items, selectIcon, context } = props;
+	const state = useMediaTypesState(stateKey, items[0]?.key);
+	const examples = items.find((item) => item.key === state.key)?.examples ?? [];
+	if (!items.length && !examples.length) return null;
+	return <StaticSection footer={items.length > 1 || examples.length > 1 ? <OpenAPIMediaTypeFooter items={items} examples={examples} selectIcon={selectIcon} stateKey={stateKey} /> : null} className="openapi-response-media-types-examples">
+            <OpenAPIMediaTypeBody context={context} stateKey={stateKey} items={items} examples={examples} />
+        </StaticSection>;
+}
+function OpenAPIMediaTypeFooter(props) {
+	const { items, examples, stateKey, selectIcon } = props;
+	return <>
+            {items.length > 1 && <OpenAPISelect icon={selectIcon} items={items} stateKey={stateKey} placement="bottom start">
+                    {items.map((item) => <OpenAPISelectItem key={item.key} id={item.key} value={item}>
+                            <span>{item.label}</span>
+                        </OpenAPISelectItem>)}
+                </OpenAPISelect>}
+
+            {examples && examples.length > 1 ? <OpenAPISelect icon={selectIcon} items={examples} stateKey={`${stateKey}-examples`} placement="bottom start">
+                    {examples.map((example) => <OpenAPISelectItem key={example.key} id={example.key} value={example}>
+                            <span>{example.label}</span>
+                        </OpenAPISelectItem>)}
+                </OpenAPISelect> : null}
+        </>;
+}
+function OpenAPIMediaTypeBody(props) {
+	const { stateKey, items, examples, context } = props;
+	const state = useMediaTypesState(stateKey, items[0]?.key);
+	const selectedItem = items.find((item) => item.key === state.key) ?? items[0];
+	const exampleState = useMediaTypeExamplesState(`${stateKey}-examples`, selectedItem?.examples?.[0]?.key);
+	if (!selectedItem) return null;
+	if (examples) {
+		const selectedExample = examples.find((example) => example.key === exampleState.key) ?? examples[0];
+		if (!selectedExample) return <OpenAPIEmptyExample context={context} />;
+		return selectedExample.body;
+	}
+	return selectedItem.body;
+}
+
+//#endregion
+//#region src/OpenAPIResponseExampleContent.tsx
+/**
+* Get the state of the response examples select.
+*/
+function useResponseExamplesState(blockKey, initialKey = "default") {
+	return useSelectState(getResponseExampleStateKey(blockKey), initialKey);
+}
+function OpenAPIResponseExampleContent(props) {
+	const { blockKey, items, selectIcon } = props;
+	return <StaticSection header={<OpenAPIResponseExampleHeader selectIcon={selectIcon} blockKey={blockKey} items={items} />} className="openapi-response-examples">
+            <OpenAPIResponseExampleBody blockKey={blockKey} items={items} />
+        </StaticSection>;
+}
+function OpenAPIResponseExampleHeader(props) {
+	const { items, blockKey, selectIcon } = props;
+	if (items.length === 1) {
+		const item = items[0];
+		if (!item) return null;
+		return <span className="openapi-response-examples-statuscode-title">
+                <OpenAPIResponseExampleItem item={item} />
+            </span>;
+	}
+	return <OpenAPISelect items={items} icon={selectIcon} stateKey={getResponseExampleStateKey(blockKey)} placement="bottom start">
+            {items.map((item) => <OpenAPISelectItem key={item.key} id={item.key} value={item}>
+                    <OpenAPIResponseExampleItem item={item} />
+                </OpenAPISelectItem>)}
+        </OpenAPISelect>;
+}
+function OpenAPIResponseExampleItem(props) {
+	const { item } = props;
+	return <>
+            <span className={clsx("openapi-statuscode", `openapi-statuscode-${getStatusCodeClassName(item.statusCode)}`, "openapi-response-examples-statuscode")}>
+                {item.statusCode}
+            </span>
+            <span className="openapi-response-examples-statuscode-label">{item.label}</span>
+        </>;
+}
+function OpenAPIResponseExampleBody(props) {
+	const { blockKey, items } = props;
+	const state = useResponseExamplesState(blockKey, items[0]?.key);
+	const selectedItem = items.find((item) => item.key === state.key) ?? items[0];
+	if (!selectedItem) return null;
+	return <div className="openapi-response-examples-panel">{selectedItem.body}</div>;
+}
+/**
+* Return the state key for the response examples.
+*/
+function getResponseExampleStateKey(blockKey) {
+	return createStateKey("openapi-responses", blockKey);
+}
+
+//#endregion
+//#region src/OpenAPIResponseExample.tsx
+/**
+* Display an example of the response content.
+*/
+function OpenAPIResponseExample(props) {
+	const { data, context } = props;
+	if (!data.operation.responses) return null;
+	const responses = Object.entries(data.operation.responses);
+	responses.sort(([a], [b]) => {
+		if (a === "default") return 1;
+		if (b === "default") return -1;
+		if (a === "200") return -1;
+		if (b === "200") return 1;
+		return Number(a) - Number(b);
+	});
+	const tabs = responses.filter(([_, responseObject]) => responseObject && typeof responseObject === "object" && !responseObject["x-hideSample"]).map(([key, responseObject]) => {
+		const description = resolveDescription(responseObject);
+		const label = description ? <Markdown key={`response-description-${key}`} source={description} /> : getStatusCodeDefaultLabel(key, context);
+		if (checkIsReference(responseObject)) return {
+			key,
+			label,
+			statusCode: key,
+			body: <OpenAPIExample example={getExampleFromReference(responseObject, context)} context={context} syntax="json" />
+		};
+		if (!responseObject.content || Object.keys(responseObject.content).length === 0) return {
+			key,
+			label,
+			statusCode: key,
+			body: <OpenAPIEmptyExample context={context} />
+		};
+		return {
+			key,
+			label,
+			statusCode: key,
+			body: <OpenAPIResponse$1 context={context} content={responseObject.content} />
+		};
+	});
+	if (tabs.length === 0) return null;
+	return <OpenAPIResponseExampleContent selectIcon={context.icons.chevronDown} blockKey={context.blockKey} items={tabs} />;
+}
+function OpenAPIResponse$1(props) {
+	const { context, content } = props;
+	const entries = Object.entries(content);
+	if (!entries[0]) throw new Error("One media type is required");
+	const tabs = entries.map((entry) => {
+		const [mediaType, mediaTypeObject] = entry;
+		if (!mediaTypeObject) return {
+			key: mediaType,
+			label: mediaType,
+			body: <OpenAPIEmptyExample context={context} />
+		};
+		return {
+			key: mediaType,
+			label: mediaType,
+			body: <></>,
+			examples: getExamples({
+				mediaTypeObject,
+				mediaType,
+				context
+			})
+		};
+	});
+	return <OpenAPIMediaTypeContent selectIcon={context.icons.chevronDown} stateKey={createStateKey("response-media-types", context.blockKey)} items={tabs} context={getOpenAPIClientContext(context)} />;
+}
+
+//#endregion
+//#region ../../node_modules/@react-stately/utils/dist/useControlledState.mjs
+function $458b0a5536c1a7cf$export$40bfa8c7b0832715(value, defaultValue, onChange) {
+	let [stateValue, setStateValue] = useState(value || defaultValue);
+	let isControlledRef = useRef(value !== void 0);
+	let isControlled = value !== void 0;
+	useEffect(() => {
+		let wasControlled = isControlledRef.current;
+		if (wasControlled !== isControlled) console.warn(`WARN: A component changed from ${wasControlled ? "controlled" : "uncontrolled"} to ${isControlled ? "controlled" : "uncontrolled"}.`);
+		isControlledRef.current = isControlled;
+	}, [isControlled]);
+	let currentValue = isControlled ? value : stateValue;
+	let setValue = useCallback((value$1, ...args) => {
+		let onChangeCaller = (value$2, ...onChangeArgs) => {
+			if (onChange) {
+				if (!Object.is(currentValue, value$2)) onChange(value$2, ...onChangeArgs);
+			}
+			if (!isControlled) currentValue = value$2;
+		};
+		if (typeof value$1 === "function") {
+			console.warn("We can not support a function callback. See Github Issues for details https://github.com/adobe/react-spectrum/issues/2320");
+			let updateFunction = (oldValue, ...functionArgs) => {
+				let interceptedValue = value$1(isControlled ? currentValue : oldValue, ...functionArgs);
+				onChangeCaller(interceptedValue, ...args);
+				if (!isControlled) return interceptedValue;
+				return oldValue;
+			};
+			setStateValue(updateFunction);
+		} else {
+			if (!isControlled) setStateValue(value$1);
+			onChangeCaller(value$1, ...args);
+		}
+	}, [
+		isControlled,
+		currentValue,
+		onChange
+	]);
+	return [currentValue, setValue];
+}
+
+//#endregion
+//#region ../../node_modules/@react-stately/disclosure/dist/useDisclosureState.mjs
+function $bf996d45f4a36925$export$3fcbf6e4407997e0(props) {
+	let [isExpanded, setExpanded] = $458b0a5536c1a7cf$export$40bfa8c7b0832715(props.isExpanded, props.defaultExpanded || false, props.onExpandedChange);
+	return {
+		isExpanded,
+		setExpanded,
+		expand: useCallback(() => {
+			setExpanded(true);
+		}, [setExpanded]),
+		collapse: useCallback(() => {
+			setExpanded(false);
+		}, [setExpanded]),
+		toggle: useCallback(() => {
+			setExpanded(!isExpanded);
+		}, [setExpanded, isExpanded])
+	};
+}
+
+//#endregion
+//#region ../../node_modules/@react-stately/disclosure/dist/useDisclosureGroupState.mjs
+function $9385b3affbdec831$export$f36461af0ef4707d(props) {
+	let { allowsMultipleExpanded = false, isDisabled = false } = props;
+	let [expandedKeys, setExpandedKeys] = $458b0a5536c1a7cf$export$40bfa8c7b0832715(useMemo(() => props.expandedKeys ? new Set(props.expandedKeys) : void 0, [props.expandedKeys]), useMemo(() => props.defaultExpandedKeys ? new Set(props.defaultExpandedKeys) : /* @__PURE__ */ new Set(), [props.defaultExpandedKeys]), props.onExpandedChange);
+	useEffect(() => {
+		if (!allowsMultipleExpanded && expandedKeys.size > 1) setExpandedKeys(new Set([expandedKeys.values().next().value]));
+	});
+	return {
+		allowsMultipleExpanded,
+		isDisabled,
+		expandedKeys,
+		setExpandedKeys,
+		toggleKey(key) {
+			let keys;
+			if (allowsMultipleExpanded) {
+				keys = new Set(expandedKeys);
+				if (keys.has(key)) keys.delete(key);
+				else keys.add(key);
+			} else keys = new Set(expandedKeys.has(key) ? [] : [key]);
+			setExpandedKeys(keys);
+		}
+	};
+}
+
+//#endregion
+//#region src/InteractiveSection.tsx
+/**
+* To optimize rendering, most of the components are server-components,
+* and the interactiveness is mainly handled by a few key components like this one.
+*/
+function InteractiveSection(props) {
+	const { id, className, toggeable = false, defaultOpened = true, tabs = [], defaultTab = tabs[0]?.key, header, overlay, toggleIcon = "▶", selectIcon, stateKey = "interactive-section" } = props;
+	const state = $bf996d45f4a36925$export$3fcbf6e4407997e0({ defaultExpanded: defaultOpened });
+	const panelRef = useRef(null);
+	const triggerRef = useRef(null);
+	const { buttonProps: triggerProps, panelProps } = useDisclosure({}, state, panelRef);
+	const { buttonProps } = useButton(triggerProps, triggerRef);
+	const { isFocusVisible, focusProps } = useFocusRing();
+	const store = useSelectState(stateKey, defaultTab);
+	const selectedTab = tabs.find((tab) => tab.key === store.key) ?? tabs[0];
+	return <Section id={id} className={clsx("openapi-section", toggeable ? "openapi-section-toggeable" : null, className, toggeable ? `${className}-${state.isExpanded ? "opened" : "closed"}` : null)}>
+            {header ? <SectionHeader onClick={() => {
+		if (toggeable) state.toggle();
+	}} className={className}>
+                    <SectionHeaderContent className={className}>
+                        {selectedTab?.body && toggeable ? <button {...mergeProps(buttonProps, focusProps)} ref={triggerRef} className={clsx("openapi-section-toggle", `${className}-toggle`)} style={{ outline: isFocusVisible ? "2px solid rgb(var(--primary-color-500) / 0.4)" : "none" }}>
+                                {toggleIcon}
+                            </button> : null}
+                        {header}
+                    </SectionHeaderContent>
+                    {}
+                    <div className={clsx("openapi-section-header-controls", `${className}-header-controls`)} onClick={(event) => {
+		event.stopPropagation();
+	}}>
+                        {tabs.length > 0 ? <OpenAPISelect stateKey={stateKey} items={tabs} onSelectionChange={() => {
+		state.expand();
+	}} icon={selectIcon} placement="bottom end">
+                                {tabs.map((tab) => <OpenAPISelectItem key={tab.key} id={tab.key} value={tab}>
+                                        {tab.label}
+                                    </OpenAPISelectItem>)}
+                            </OpenAPISelect> : null}
+                    </div>
+                </SectionHeader> : null}
+            {(!toggeable || state.isExpanded) && selectedTab?.body ? <SectionBody ref={panelRef} {...panelProps} className={className}>
+                    {selectedTab?.body}
+                </SectionBody> : null}
+            {overlay ? <div className={clsx("openapi-section-overlay", `${className}-overlay`)}>
+                    {overlay}
+                </div> : null}
+        </Section>;
+}
+
+//#endregion
+//#region src/OpenAPIRequestBodyHeaderType.tsx
+/**
+* Display the type of a request body. It only displays the type if the selected content is an array.
+*/
+function OpenAPIRequestBodyHeaderType(props) {
+	const { requestBody, stateKey } = props;
+	const content = requestBody.content ?? {};
+	const state = useSelectState(stateKey, Object.keys(content)[0]);
+	const selectedContentMediaType = Object.entries(content).find(([contentType]) => contentType === state.key)?.[1];
+	if (!selectedContentMediaType || !selectedContentMediaType.schema?.type || selectedContentMediaType.schema.type !== "array") return null;
+	return <span className="openapi-requestbody-header-type">
+            {`${getSchemaTitle(selectedContentMediaType.schema)}`}
+        </span>;
+}
+
+//#endregion
+//#region src/OpenAPIRequestBody.tsx
+/**
+* Display an interactive request body.
+*/
+function OpenAPIRequestBody(props) {
+	const { requestBody, context, data } = props;
+	if (checkIsReference(requestBody)) return null;
+	const stateKey = createStateKey("request-body-media-type", context.blockKey);
+	return <InteractiveSection header={<>
+                    <span>{t(context.translation, "name" in data ? "payload" : "body")}</span>
+                    <OpenAPIRequestBodyHeaderType requestBody={requestBody} stateKey={stateKey} />
+                </>} className="openapi-requestbody" stateKey={stateKey} selectIcon={context.icons.chevronDown} tabs={Object.entries(requestBody.content ?? {}).map(([contentType, mediaTypeObject]) => {
+		return {
+			key: contentType,
+			label: contentType,
+			body: <OpenAPIRootSchema schema={mediaTypeObject.schema ?? {}} context={context} key={contentType} />
+		};
+	})} />;
+}
+
+//#endregion
+//#region src/OpenAPIDisclosureGroup.tsx
+const DisclosureGroupStateContext = createContext(null);
+/**
+* Display an interactive OpenAPI disclosure group.
+*/
+function OpenAPIDisclosureGroup(props) {
+	const { icon, groups, selectStateKey, selectIcon } = props;
+	const state = $9385b3affbdec831$export$f36461af0ef4707d(props);
+	return <DisclosureGroupStateContext.Provider value={state}>
+            {groups.map((group) => <DisclosureItem selectStateKey={selectStateKey} selectIcon={selectIcon} icon={icon} key={group.key} group={group} />)}
+        </DisclosureGroupStateContext.Provider>;
+}
+function DisclosureItem(props) {
+	const { icon, group, selectStateKey, selectIcon } = props;
+	const defaultId = useId$1();
+	const id = group.key || defaultId;
+	const groupState = useContext(DisclosureGroupStateContext);
+	const isExpanded = groupState?.expandedKeys.has(id) || false;
+	const state = $bf996d45f4a36925$export$3fcbf6e4407997e0({
+		isExpanded,
+		onExpandedChange() {
+			if (groupState) groupState.toggleKey(id);
+		}
+	});
+	const panelRef = useRef(null);
+	const triggerRef = useRef(null);
+	const isDisabled = groupState?.isDisabled || !group.tabs?.length || false;
+	const { buttonProps: triggerProps, panelProps } = useDisclosure({
+		...props,
+		isExpanded,
+		isDisabled
+	}, state, panelRef);
+	const { buttonProps } = useButton(triggerProps, triggerRef);
+	const { isFocusVisible, focusProps } = useFocusRing();
+	const store = useSelectState(selectStateKey, group.tabs?.[0]?.key || "");
+	const selectedTab = group.tabs?.find((tab) => tab.key === store.key) || group.tabs?.[0];
+	return <div className="openapi-disclosure-group" aria-expanded={state.isExpanded}>
+            <div slot="trigger" ref={triggerRef} {...mergeProps(buttonProps, focusProps)} aria-disabled={isDisabled} style={{ outline: isFocusVisible ? "2px solid rgb(var(--primary-color-500)/0.4)" : "none" }} className="openapi-disclosure-group-trigger">
+                <div className="openapi-disclosure-group-icon">
+                    {icon || <svg viewBox="0 0 24 24" className="openapi-disclosure-group-icon">
+                            <path d="m8.25 4.5 7.5 7.5-7.5 7.5" />
+                        </svg>}
+                </div>
+
+                <div className="openapi-disclosure-group-label">
+                    {group.label}
+
+                    {group.tabs ? <div className="openapi-disclosure-group-mediatype" onClick={(e) => e.stopPropagation()}>
+                            {group.tabs?.length > 1 ? <OpenAPISelect icon={selectIcon} stateKey={selectStateKey} onSelectionChange={() => {
+		state.expand();
+	}} items={group.tabs} placement="bottom end">
+                                    {group.tabs.map((tab) => <OpenAPISelectItem key={tab.key} id={tab.key} value={tab}>
+                                            {tab.label}
+                                        </OpenAPISelectItem>)}
+                                </OpenAPISelect> : group.tabs[0]?.label ? <span>{group.tabs[0].label}</span> : null}
+                        </div> : null}
+                </div>
+            </div>
+
+            {state.isExpanded && selectedTab && <div className="openapi-disclosure-group-panel" ref={panelRef} {...panelProps}>
+                    {selectedTab.body}
+                </div>}
+        </div>;
+}
+
+//#endregion
+//#region src/OpenAPIResponse.tsx
+/**
+* Display an interactive response body.
+*/
+function OpenAPIResponse(props) {
+	const { response, context, mediaType } = props;
+	const headers = Object.entries(response.headers ?? {}).map(([name, header]) => [name, header ?? {}]);
+	const content = Object.entries(mediaType?.schema ?? {});
+	const description = resolveDescription(response);
+	if (content.length === 0 && !description && headers.length === 0) return null;
+	return <div className="openapi-response-body">
+            {headers.length > 0 ? <OpenAPIDisclosure header={<OpenAPISchemaPresentation context={context} property={{
+		propertyName: tString(context.translation, "headers"),
+		schema: { type: "object" },
+		required: null
+	}} />} icon={context.icons.plus} label={(isExpanded) => tString(context.translation, isExpanded ? "hide" : "show", tString(context.translation, headers.length === 1 ? "header" : "headers"))}>
+                    <OpenAPISchemaProperties properties={headers.map(([name, header]) => parameterToProperty({
+		name,
+		...header
+	}))} context={context} />
+                </OpenAPIDisclosure> : null}
+            {mediaType?.schema && <div className="openapi-responsebody">
+                    <OpenAPISchemaProperties id={`response-${context.blockKey}`} properties={[{
+		schema: mediaType.schema,
+		propertyName: tString(context.translation, "response"),
+		required: null
+	}]} context={context} />
+                </div>}
+        </div>;
+}
+
+//#endregion
+//#region src/OpenAPIResponses.tsx
+/**
+* Display an interactive response body.
+*/
+function OpenAPIResponses(props) {
+	const { responses, context } = props;
+	const groups = Object.entries(responses).filter(([_, response]) => response && typeof response === "object").map(([statusCode, response]) => {
+		const tabs = (() => {
+			if ((!response.content || !Object.keys(response.content).length) && response.headers && Object.keys(response.headers).length) return [{
+				key: "default",
+				label: "",
+				body: <OpenAPIResponse response={response} mediaType={{}} context={context} />
+			}];
+			if (!response.content) return [{
+				key: "default",
+				label: "",
+				body: <pre className="openapi-example-empty">
+                                    <p>{t(context.translation, "no_content")}</p>
+                                </pre>
+			}];
+			return Object.entries(response.content ?? {}).map(([contentType, mediaType]) => ({
+				key: contentType,
+				label: contentType,
+				body: <OpenAPIResponse response={response} mediaType={mediaType} context={context} />
+			}));
+		})();
+		const description = resolveDescription(response);
+		return {
+			key: statusCode,
+			label: <div className="openapi-response-tab-content">
+                        <span className={clsx("openapi-statuscode", `openapi-statuscode-${getStatusCodeClassName(statusCode)}`)}>
+                            {statusCode}
+                        </span>
+                        {description ? <Markdown source={description} className="openapi-response-description" /> : getStatusCodeDefaultLabel(statusCode, context)}
+                    </div>,
+			tabs
+		};
+	});
+	const state = useResponseExamplesState(context.blockKey, groups[0]?.key);
+	return <StaticSection header={t(context.translation, "responses")} className="openapi-responses">
+            <OpenAPIDisclosureGroup icon={context.icons.chevronRight} expandedKeys={state.key ? new Set([state.key]) : /* @__PURE__ */ new Set()} onExpandedChange={(keys) => {
+		const key = keys.values().next().value ?? null;
+		state.setKey(key);
+	}} groups={groups} selectIcon={context.icons.chevronDown} selectStateKey={createStateKey("response-media-types", context.blockKey)} />
+        </StaticSection>;
+}
+
+//#endregion
+//#region src/OpenAPISecurities.tsx
+/**
+* Present securities authorization that can be used for this operation.
+*/
+function OpenAPISecurities(props) {
+	const { securityRequirement, securities, context } = props;
+	if (!securities || securities.length === 0) return null;
+	const tabsData = extractOperationSecurityInfo({
+		securityRequirement,
+		securities
+	});
+	return <InteractiveSection header={t(context.translation, "authorizations")} stateKey={createStateKey("securities", context.blockKey)} toggeable defaultOpened={false} toggleIcon={context.icons.chevronRight} selectIcon={context.icons.chevronDown} className="openapi-securities" tabs={tabsData.map(({ key, label, schemes }) => ({
+		key,
+		label,
+		body: <div className="openapi-schema">
+                        {schemes.map((security, index) => {
+			const description = resolveDescription(security);
+			return <div key={`${key}-${index}`} className="openapi-schema-presentation">
+                                    {getLabelForType(security, context)}
+                                    {description ? <Markdown source={description} className="openapi-securities-description" /> : null}
+                                    {security.scopes?.length ? <OpenAPISchemaScopes scopes={security.scopes} context={context} /> : null}
+                                </div>;
+		})}
+                    </div>
+	}))} />;
+}
+function getLabelForType(security, context) {
+	switch (security.type) {
+		case "apiKey": return <OpenAPISchemaName context={context} propertyName={security.name ?? "apiKey"} type="string" required={security.required} />;
+		case "http":
+			if (security.scheme === "basic") return <OpenAPISchemaName context={context} propertyName="Authorization" type="string" required={security.required} />;
+			if (security.scheme === "bearer") return <>
+                        <OpenAPISchemaName context={context} propertyName="Authorization" type="string" required={security.required} />
+                        {			/** Show a default description if none is provided */}
+                        {!security.description ? <Markdown source={`Bearer authentication header of the form Bearer &lt;token&gt;.`} className="openapi-securities-description" /> : null}
+                    </>;
+ return <OpenAPISchemaName context={context} propertyName="HTTP" required={security.required} />;
+		case "oauth2": return <OpenAPISchemaOAuth2Flows context={context} security={security} />;
+		case "openIdConnect": return <OpenAPISchemaName context={context} propertyName="OpenID Connect" required={security.required} />;
+		default: return security.type;
+	}
+}
+function OpenAPISchemaOAuth2Flows(props) {
+	const { context, security } = props;
+	const flows = security.flows ? Object.entries(security.flows) : [];
+	return <div className="openapi-securities-oauth-flows">
+            {flows.map(([name, flow], index) => <Fragment key={index}>
+                    <OpenAPISchemaOAuth2Item flow={flow} name={name} context={context} security={security} />
+                    {index < flows.length - 1 ? <hr /> : null}
+                </Fragment>)}
+        </div>;
+}
+function OpenAPISchemaOAuth2Item(props) {
+	const { flow, context, security, name } = props;
+	if (!flow) return null;
+	const scopes = flow.scopes ? Object.entries(flow.scopes) : [];
+	return <div>
+            <OpenAPISchemaName context={context} propertyName="OAuth2" type={name} required={security.required} />
+            <div className="openapi-securities-oauth-content openapi-markdown">
+                {security.description ? <Markdown source={security.description} /> : null}
+                {"authorizationUrl" in flow && flow.authorizationUrl ? <span>
+                        Authorization URL:{" "}
+                        <OpenAPICopyButton value={flow.authorizationUrl} context={context} className="openapi-securities-url" withTooltip>
+                            {flow.authorizationUrl}
+                        </OpenAPICopyButton>
+                    </span> : null}
+                {"tokenUrl" in flow && flow.tokenUrl ? <span>
+                        Token URL:{" "}
+                        <OpenAPICopyButton value={flow.tokenUrl} context={context} className="openapi-securities-url" withTooltip>
+                            {flow.tokenUrl}
+                        </OpenAPICopyButton>
+                    </span> : null}
+                {"refreshUrl" in flow && flow.refreshUrl ? <span>
+                        Refresh URL:{" "}
+                        <OpenAPICopyButton value={flow.refreshUrl} context={context} className="openapi-securities-url" withTooltip>
+                            {flow.refreshUrl}
+                        </OpenAPICopyButton>
+                    </span> : null}
+                {scopes.length ? <OpenAPISchemaScopes scopes={scopes} context={context} /> : null}
+            </div>
+        </div>;
+}
+/**
+* Render a list of available scopes.
+*/
+function OpenAPISchemaScopes(props) {
+	const { scopes, context } = props;
+	return <div className="openapi-securities-scopes openapi-markdown">
+            <span>{t(context.translation, "required_scopes")}: </span>
+            <ul>
+                {scopes.map((scope) => <OpenAPIScopeItem key={scope[0]} scope={scope} context={context} />)}
+            </ul>
+        </div>;
+}
+/**
+* Display a scope item. Either a key-value pair or a single string.
+*/
+function OpenAPIScopeItem(props) {
+	const { scope, context } = props;
+	return <li>
+            <OpenAPIScopeItemKey name={scope[0]} context={context} />
+            {scope[1] ? `: ${scope[1]}` : null}
+        </li>;
+}
+/**
+* Displays the scope name within a copyable button.
+*/
+function OpenAPIScopeItemKey(props) {
+	const { name, context } = props;
+	return <OpenAPICopyButton value={name} context={context} withTooltip>
+            <code>{name}</code>
+        </OpenAPICopyButton>;
+}
+
+//#endregion
+//#region src/OpenAPISpec.tsx
+function OpenAPISpec(props) {
+	const { data, context } = props;
+	const { operation } = data;
+	const parameterGroups = groupParameters(deduplicateParameters(operation.parameters ?? []), context);
+	const securities = "securities" in data ? data.securities : [];
+	return <>
+            {securities.length > 0 ? <OpenAPISecurities key="securities" securityRequirement={operation.security} securities={securities} context={context} /> : null}
+
+            {parameterGroups.map((group) => {
+		return <StaticSection key={`parameter-${group.key}`} className="openapi-parameters" header={group.label}>
+                        <OpenAPISchemaProperties properties={group.parameters.map(parameterToProperty)} context={context} />
+                    </StaticSection>;
+	})}
+
+            {operation.requestBody ? <OpenAPIRequestBody key="body" requestBody={operation.requestBody} context={context} data={data} /> : null}
+            {operation.responses ? <OpenAPIResponses key="responses" responses={operation.responses} context={context} /> : null}
+        </>;
+}
+function groupParameters(parameters, context) {
+	const sorted = [
+		"path",
+		"query",
+		"header"
+	];
+	const groups = [];
+	parameters.filter((parameter) => parameter.in).forEach((parameter) => {
+		const key = parameter.in;
+		const label = getParameterGroupName(parameter.in, context);
+		const group = groups.find((group$1) => group$1.key === key);
+		if (group) group.parameters.push(parameter);
+		else groups.push({
+			key,
+			label,
+			parameters: [parameter]
+		});
+	});
+	groups.sort((a, b) => sorted.indexOf(a.key) - sorted.indexOf(b.key));
+	return groups;
+}
+function getParameterGroupName(paramIn, context) {
+	switch (paramIn) {
+		case "path": return tString(context.translation, "path_parameters");
+		case "query": return tString(context.translation, "query_parameters");
+		case "header": return tString(context.translation, "header_parameters");
+		default: return paramIn;
+	}
+}
+/** Deduplicate parameters by name and in.
+* Some specs have both parameters define at path and operation level.
+* We only want to display one of them.
+* Parameters can have the wrong type (object instead of array) sometimes, we just return an empty array in that case.
+*/
+function deduplicateParameters(parameters) {
+	const seen = /* @__PURE__ */ new Set();
+	return Array.isArray(parameters) ? parameters.filter((param) => {
+		const key = `${param.name}:${param.in}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	}) : [];
+}
+
+//#endregion
+//#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
+//#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
+//#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
+//#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
+//#region src/OpenAPIOperation.tsx
+/**
+* Display an interactive OpenAPI operation.
+*/
+function OpenAPIOperation(props) {
+	const { className, data, context: contextInput } = props;
+	const context = resolveOpenAPIContext(contextInput);
+	return <div className={clsx("openapi-operation", 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">
+                        <OpenAPICodeSample data={data} context={context} />
+                        <OpenAPIResponseExample data={data} context={context} />
+                    </div>
+                </div>
+            </div>
+        </div>;
+}
+
+//#endregion
+//#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
+//#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
+//#region src/resolveOpenAPIOperation.ts
+/**
+* Resolve an OpenAPI operation in a file and compile it to a more usable format.
+*/
+async function resolveOpenAPIOperation(filesystem, operationDescriptor) {
+	const { path, method } = operationDescriptor;
+	const schema = await dereferenceFilesystem(filesystem);
+	let operation = getOperationByPathAndMethod(schema, path, method);
+	if (!operation) return null;
+	const commonParameters = getPathObjectParameter$1(schema, path);
+	if (commonParameters) operation = {
+		...operation,
+		parameters: [...commonParameters, ...operation.parameters ?? []]
+	};
+	const servers = "servers" in schema ? schema.servers ?? [] : [];
+	const schemaSecurity = Array.isArray(schema.security) ? schema.security : schema.security ? [schema.security] : [];
+	const security = operation.security ?? schemaSecurity;
+	const isOptionalSecurity = security.some((entry) => Object.keys(entry).length === 0);
+	const flatSecurities = flattenSecurities(security);
+	const securities = [];
+	for (const entry of flatSecurities) {
+		const [securityKey, operationScopes] = Object.entries(entry)[0] ?? [];
+		if (securityKey) {
+			const securityScheme = schema.components?.securitySchemes?.[securityKey];
+			const scopes = resolveSecurityScopes({
+				securityScheme,
+				operationScopes
+			});
+			securities.push([securityKey, {
+				...securityScheme,
+				required: !isOptionalSecurity,
+				scopes
+			}]);
+		}
+	}
+	return {
+		servers,
+		operation: {
+			...operation,
+			security
+		},
+		method,
+		path,
+		securities,
+		"x-codeSamples": typeof schema["x-codeSamples"] === "boolean" ? schema["x-codeSamples"] : void 0,
+		"x-hideTryItPanel": typeof schema["x-hideTryItPanel"] === "boolean" ? schema["x-hideTryItPanel"] : void 0
+	};
+}
+/**
+* Get a path object from its path.
+*/
+function getPathObject$1(schema, path) {
+	return schema.paths?.[path] || null;
+}
+/**
+* Resolve parameters from a path in an OpenAPI schema.
+*/
+function getPathObjectParameter$1(schema, path) {
+	const pathObject = getPathObject$1(schema, path);
+	if (pathObject?.parameters) return pathObject.parameters;
+	return null;
+}
+/**
+* Get an operation by its path and method.
+*/
+function getOperationByPathAndMethod(schema, path, method) {
+	const pathObject = getPathObject$1(schema, path);
+	if (!pathObject) return null;
+	const normalizedMethod = method.toLowerCase();
+	if (!pathObject[normalizedMethod]) return null;
+	return pathObject[normalizedMethod];
+}
+/**
+* Flatten security objects in case they are nested.
+* @example [{bearerAuth:[], basicAuth:[]}] => [{ bearerAuth: [] }, { basicAuth: [] }]
+*/
+function flattenSecurities(security) {
+	if (!Array.isArray(security) || security.length === 0) return [];
+	return security.flatMap((securityObject) => {
+		return Object.entries(securityObject).map(([authType, config]) => ({ [authType]: config }));
+	});
+}
+/**
+* Resolve the scopes for a security scheme.
+*/
+function resolveSecurityScopes({ securityScheme, operationScopes }) {
+	if (!securityScheme || checkIsReference(securityScheme) || isOAuthSecurityScheme(securityScheme)) return null;
+	return operationScopes?.map((scope) => [scope, void 0]) || [];
+}
+/**
+* Check if a security scheme is an OAuth or OpenID Connect security scheme.
+*/
+function isOAuthSecurityScheme(securityScheme) {
+	return securityScheme.type === "oauth2";
+}
+
+//#endregion
+//#region src/resolveOpenAPIWebhook.ts
+/**
+* Resolve an OpenAPI webhook in a file and compile it to a more usable format.
+*/
+async function resolveOpenAPIWebhook(filesystem, webhookDescriptor) {
+	const { name, method } = webhookDescriptor;
+	const schema = await dereferenceFilesystem(filesystem);
+	let operation = getWebhookByNameAndMethod(schema, name, method);
+	if (!operation) return null;
+	const commonParameters = getPathObjectParameter(schema, name);
+	if (commonParameters) operation = {
+		...operation,
+		parameters: [...commonParameters, ...operation.parameters ?? []]
+	};
+	return {
+		servers: "servers" in schema ? schema.servers ?? [] : [],
+		operation,
+		method,
+		name
+	};
+}
+/**
+* Get a path object from its path.
+*/
+function getPathObject(schema, name) {
+	if (schema.webhooks?.[name]) return schema.webhooks[name];
+	return null;
+}
+/**
+* Resolve parameters from a path in an OpenAPI schema.
+*/
+function getPathObjectParameter(schema, path) {
+	const pathObject = getPathObject(schema, path);
+	if (pathObject?.parameters) return pathObject.parameters;
+	return null;
+}
+/**
+* Get an operation by its path and method.
+*/
+function getWebhookByNameAndMethod(schema, name, method) {
+	const pathObject = getPathObject(schema, name);
+	if (!pathObject) return null;
+	const normalizedMethod = method.toLowerCase();
+	if (!pathObject[normalizedMethod]) return null;
+	return pathObject[normalizedMethod];
+}
+
+//#endregion
+export { OpenAPIOperation, OpenAPIOperationContextProvider, OpenAPIPrefillContextProvider, OpenAPISchemas, OpenAPIWebhook, checkIsValidLocale, resolveOpenAPIOperation, resolveOpenAPISchemas, resolveOpenAPIWebhook, useOpenAPIOperationContext, useOpenAPIPrefillContext };