@stainless-api/docs-ui 0.1.0-beta.24 → 0.1.0-beta.26

package/dist/contexts-DO0sMzym.js

@@ -0,0 +1,2581 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { a as useLanguage, c as useSnippet, i as useDocs, l as useSpec, n as useContentPanelLayout, o as useResource, r as useDeclaration, s as useSettings, t as DocsProvider } from "./docs-Cj25B-Sh.js";
+import { a as createStrictContext, i as useComponents$1, n as customizeComponents, r as useComponentContext, t as ComponentProvider$1 } from "./component-generics-Df4EDvxk.js";
+import { n as useNavigation, t as NavigationProvider } from "./navigation-CuCg3le8.js";
+import { a as useRenderMarkdown, i as useMarkdownContext, n as MarkdownProvider, r as useHighlight, t as MarkdownContext } from "./markdown-DunIdqFE.js";
+import { _ as walkTree, c as getLanguageSnippet, f as parseStainlessPath, n as Languages, o as generateRoute } from "./routing-C8oZYLsf.js";
+import { t as style_default } from "./style-CkbsakoF.js";
+import { t as useComponents } from "./use-components-DI-AbT-D.js";
+import { a as PowershellIcon, c as TerraformIcon, i as KotlinIcon, l as TypescriptIcon, n as GoIcon, o as PythonIcon, r as JavaIcon, s as RubyIcon, t as CurlIcon } from "./icons--8QR-PrL.js";
+import { n as getResourceFromSpec, r as isResourceEmpty, t as flatResources } from "./utils-BhYTrLot.js";
+import { i as DropdownTrigger, n as DropdownItem, r as DropdownMenu, t as Dropdown } from "./dropdown-kUhwBigR.js";
+import { a as item, c as parse, l as strong, n as fence, o as list, r as heading, s as paragraph, t as code, u as text } from "./md-Dg8aOyMA.js";
+import { n as getSnippet, r as stripMarkup, t as getDecl } from "./utils-ByZH9QWT.js";
+import { n as SearchableAttributes, r as SearchableAttributesChat } from "./types-DFN4M1Sp.js";
+import * as React$1 from "react";
+import React, { Fragment, useState } from "react";
+import { searchClient } from "@algolia/client-search";
+import { renderToStaticMarkup } from "react-dom/server";
+import { ArrowDownLeft, ArrowDownWideNarrowIcon, ArrowUpNarrowWideIcon, ArrowUpRight, BookOpen, CheckIcon, ChevronDown, ChevronRight, CircleAlertIcon, Copy, CopyIcon, Github, MinusIcon, PlusIcon, X } from "lucide-react";
+import clsx from "clsx";
+import { Button } from "@stainless-api/ui-primitives";
+import Markdoc from "@markdoc/markdoc";
+
+//#region src/components/properties.tsx
+function PropertyToggle({ target }) {
+	return <span className={style_default.ExpandToggle} data-stldocs-property-toggle-expanded="false" data-stldocs-property-toggle-target={target}>
+      <span className={style_default.ExpandToggleContent}>
+        Expand <ArrowDownWideNarrowIcon className={style_default.Icon} size={16} />
+      </span>
+      <span className={style_default.ExpandToggleContent}>
+        Collapse <ArrowUpNarrowWideIcon className={style_default.Icon} size={16} />
+      </span>
+    </span>;
+}
+function PropertyDescription({ description }) {
+	const { Markdown: Markdown$1 } = useComponents();
+	if (description) return <div className={style_default.PropertyDescription}>
+        <Markdown$1 content={description} />
+      </div>;
+}
+function Property$6({ id, name, typeName: typeName$1, badges, type, declaration: declaration$2, description, deprecated, expand, additional, constraints, children }) {
+	const Docs = useComponents();
+	const language = useLanguage();
+	const properties = useSettings()?.properties;
+	const collapseDescription = properties?.collapseDescription;
+	const types = properties?.types;
+	const textContent = <>
+      {typeof deprecated === "string" && <div className={style_default.PropertyDeprecatedMessage}>{deprecated}</div>}
+      {description && <Docs.PropertyDescription description={description} />}
+      {constraints && <div className={style_default.PropertyContent}>{constraints}</div>}
+    </>;
+	const rich = <>
+      <div className={style_default.PropertyDeclaration}>
+        {deprecated && <span className={style_default.PropertyDeprecated}>Deprecated</span>}
+        {declaration$2}
+        {badges && <span className={style_default.PropertyBadges}>{badges}</span>}
+      </div>
+      {collapseDescription === false ? textContent : null}
+    </>;
+	const simple = <>
+      {name && <div className={style_default.PropertyHeader}>
+          {deprecated && <span className={style_default.PropertyDeprecated}>Deprecated</span>}
+          {name && <span className={style_default.PropertyName}>{name}</span>}
+          {typeName$1 && <span className={style_default.PropertyTypeName}>{typeName$1}</span>}
+          {badges && <span className={style_default.PropertyBadges}>{badges}</span>}
+        </div>}
+      {type && <div className={style_default.PropertyType}>{type}</div>}
+      {collapseDescription === false ? textContent : null}
+    </>;
+	const content = <div id={id} className={style_default.PropertyInfo}>
+      {types === "simple" ? simple : rich}
+    </div>;
+	return <div className={style_default.Property} data-stldocs-language={language}>
+      {children || collapseDescription !== false && description ? <Docs.Expander summary={content} muted={!children} open={expand}>
+          {collapseDescription !== false ? textContent : null}
+          {additional}
+          {children && <div className={style_default.PropertyChildren}>{children}</div>}
+        </Docs.Expander> : content}
+    </div>;
+}
+
+//#endregion
+//#region src/components/method.tsx
+const HttpMethods = [
+	"get",
+	"head",
+	"put",
+	"delete",
+	"post",
+	"patch"
+];
+const HttpMethodIcons = {
+	get: ArrowDownLeft,
+	put: ArrowUpRight,
+	post: ArrowUpRight,
+	patch: ArrowUpRight,
+	delete: X
+};
+function MethodIconBadge({ httpMethod, showName }) {
+	if (!httpMethod || !HttpMethods.includes(httpMethod)) return null;
+	return <span className={clsx(style_default.MethodRouteHttpMethod, style_default.MethodRouteHttpMethodIconOnly)} data-method={httpMethod}>
+      {HttpMethodIcons[httpMethod] && React$1.createElement(HttpMethodIcons[httpMethod], {
+		size: 14,
+		strokeWidth: 3,
+		className: style_default.Icon
+	})}
+      {showName && httpMethod}
+    </span>;
+}
+function MethodHeader({ title, badges, signature, children, level }) {
+	const Heading = level ?? "h5";
+	return <div className={style_default.MethodHeader}>
+      <Heading className={style_default.MethodTitle}>{title}</Heading>
+      {badges && <div className={style_default.MethodBadges}>{badges}</div>}
+      {signature}
+      {children}
+    </div>;
+}
+function MethodRoute({ httpMethod, endpoint, iconOnly }) {
+	return <div className={style_default.MethodRoute}>
+      <MethodIconBadge httpMethod={httpMethod} showName={!iconOnly} />
+      {endpoint && <span className={style_default.MethodRouteEndpoint}>{endpoint}</span>}
+    </div>;
+}
+function MethodDescription({ description }) {
+	const { Markdown: Markdown$1 } = useComponents();
+	if (description) return <div className={style_default.MethodDescription}>
+        <Markdown$1 content={description} />
+      </div>;
+}
+function MethodInfo$1({ children, parameters, returns }) {
+	return <div className={style_default.MethodInfo}>
+      {children && <div className={style_default.MethodContent}>{children}</div>}
+
+      {parameters && <div className={style_default.MethodInfoSection}>
+          <h5>
+            Parameters
+            <PropertyToggle target="parameters" />
+          </h5>
+          <div className={style_default.MethodParameters} data-stldocs-property-group="parameters">
+            {parameters}
+          </div>
+        </div>}
+
+      {returns && <div className={style_default.MethodInfoSection}>
+          <h5>
+            Returns
+            <PropertyToggle target="returns" />
+          </h5>
+          <div className={style_default.MethodReturns} data-stldocs-property-group="returns">
+            {returns}
+          </div>
+        </div>}
+    </div>;
+}
+function Method({ id, header, children, className,...props }) {
+	return <div id={id} className={clsx(style_default.Method, className)} tabIndex={0} {...props}>
+      {header}
+      <div className={style_default.MethodBody}>{children}</div>
+    </div>;
+}
+
+//#endregion
+//#region src/components/primitives.tsx
+function Join({ items, limit, children }) {
+	return (limit && items.length > limit + 1 ? [...items.slice(0, limit), <span className={style_default.Truncation} key="truncation">
+            {items.length - limit} more
+          </span>] : items).map((item$1, index) => <Fragment key={`iterator:${index}`}>
+      {!!index && children}
+      {item$1}
+    </Fragment>);
+}
+function Expander({ id, open, summary, virtual, muted, children }) {
+	const virtualExpanders = useSettings()?.virtualExpanders;
+	if (virtual || virtualExpanders) return <VirtualExpander summary={summary} open={open} muted={muted} id={id}>
+        {children}
+      </VirtualExpander>;
+	return <details className={style_default.Expander} open={open} data-stldocs-expander-muted={muted} data-stldocs-expander-initial-state={open}>
+      <summary className={style_default.ExpanderSummary}>
+        <div className={style_default.ExpanderSummaryIcon}>
+          <PlusIcon size={16} strokeWidth={1} className={style_default.Icon} />
+          <MinusIcon size={16} strokeWidth={1} className={style_default.Icon} />
+        </div>
+        <div className={style_default.ExpanderSummaryContent}>{summary}</div>
+      </summary>
+      <div className={style_default.ExpanderContent} id={id}>
+        {children}
+      </div>
+    </details>;
+}
+function VirtualExpander({ id, open: isOpen, muted, summary, children }) {
+	const [open, setOpen] = useState(isOpen);
+	React$1.useEffect(() => {
+		if (isOpen) setOpen(true);
+	}, [isOpen]);
+	return <div className={style_default.Expander} data-open={open} data-stldocs-expander-muted={muted} data-stldocs-expander-initial-state={open}>
+      <div className={style_default.ExpanderSummary} onClick={() => setOpen(!open)}>
+        <div className={style_default.ExpanderSummaryIcon}>
+          <PlusIcon size={16} className={style_default.Icon} />
+          <MinusIcon size={16} className={style_default.Icon} />
+        </div>
+        <div className={style_default.ExpanderSummaryContent}>{summary}</div>
+      </div>
+      {open && <div className={style_default.ExpanderContent} id={id}>
+          {children}
+        </div>}
+    </div>;
+}
+function Markdown({ content }) {
+	const rendered = useRenderMarkdown(content);
+	return rendered && <div className={`${style_default.Markdown} ${style_default.Content}`} dangerouslySetInnerHTML={{ __html: rendered }} />;
+}
+function Badge({ id, children }) {
+	return <span className={style_default.Badge} data-badge-id={id}>
+      {children ?? id}
+    </span>;
+}
+const TooltipNestingContext = React$1.createContext(false);
+function Tooltip({ content, children }) {
+	if (React$1.useContext(TooltipNestingContext)) return children;
+	return <span className={style_default.Tooltip}>
+      <span className={style_default.TooltipContent}>
+        <TooltipNestingContext.Provider value={true}>{content}</TooltipNestingContext.Provider>
+      </span>
+      <span className={style_default.TooltipHost}>{children}</span>
+    </span>;
+}
+function Link({ stainlessPath, scroll = true, children,...props }) {
+	const { basePath, onNavigate } = useNavigation();
+	const language = useLanguage();
+	const href = React$1.useMemo(() => {
+		if (props.href) return props.href;
+		if (stainlessPath && basePath) return generateRoute(basePath, language, stainlessPath);
+	}, [
+		basePath,
+		language,
+		stainlessPath,
+		props.href
+	]);
+	const handleClick = React$1.useCallback((e) => {
+		if (props.onClick) props.onClick(e);
+		if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+		if (href) onNavigate?.(e, {
+			href,
+			language,
+			stainlessPath,
+			scroll
+		});
+	}, [
+		href,
+		scroll,
+		onNavigate,
+		language,
+		props,
+		stainlessPath
+	]);
+	if (!href) return children;
+	return <a href={href} onClick={handleClick} {...props}>
+      {children}
+    </a>;
+}
+const Input = React$1.forwardRef(function Input$1({ left, right,...props }, ref) {
+	return <div className={style_default.Input}>
+      {left}
+      <input {...props} ref={ref} className={style_default.InputTextField} />
+      {right}
+    </div>;
+});
+const ToggleButton = React$1.forwardRef(function ToggleButton$1({ children, selected,...props }, ref) {
+	return <button {...props} ref={ref} className={style_default.ToggleButton} data-stldocs-toggle-selected={selected}>
+      {children}
+    </button>;
+});
+function ListView({ items, itemDelegate, onSelectListItem,...rest }) {
+	const [selectedIndex, setSelectedIndex] = React$1.useState(0);
+	const [keyboardIndex, setKeyboardIndex] = React$1.useState(0);
+	const listRef = React$1.useRef(null);
+	const itemRef = React$1.useRef(null);
+	React$1.useEffect(() => {
+		setSelectedIndex(0);
+		setKeyboardIndex(0);
+	}, [items]);
+	const handleSelect = React$1.useCallback(() => {
+		const item$1 = items[selectedIndex];
+		if (item$1) onSelectListItem?.(item$1);
+	}, [
+		items,
+		selectedIndex,
+		onSelectListItem
+	]);
+	React$1.useEffect(() => {
+		function handleKeyPress(ev) {
+			switch (ev.key) {
+				case "ArrowUp": {
+					ev.preventDefault();
+					const value = Math.max(0, selectedIndex - 1);
+					setSelectedIndex(value);
+					setKeyboardIndex(value);
+					break;
+				}
+				case "ArrowDown": {
+					ev.preventDefault();
+					const value = Math.min(items.length, selectedIndex + 1);
+					setSelectedIndex(value);
+					setKeyboardIndex(value);
+					break;
+				}
+				case "Enter":
+					ev.preventDefault();
+					handleSelect();
+					break;
+			}
+		}
+		addEventListener("keydown", handleKeyPress);
+		return () => removeEventListener("keydown", handleKeyPress);
+	}, [
+		items,
+		selectedIndex,
+		handleSelect
+	]);
+	React$1.useEffect(() => {
+		if (!keyboardIndex || !itemRef.current || !listRef.current) {
+			listRef?.current?.scroll(0, 0);
+			return;
+		}
+		const selectedBounds = itemRef.current.getBoundingClientRect();
+		const listBounds = listRef.current.getBoundingClientRect();
+		if (selectedBounds.top < listBounds.top || selectedBounds.bottom > listBounds.bottom) itemRef.current.scrollIntoView({ block: "nearest" });
+	}, [
+		keyboardIndex,
+		items,
+		listRef
+	]);
+	return <div ref={listRef} className={style_default.ListView} tabIndex={0} {...rest}>
+      {items.map((item$1, index) => <div key={index} ref={index === selectedIndex ? itemRef : null} className={style_default.ListViewItem} data-stldocs-listview-selected={index === selectedIndex} onClick={handleSelect} onMouseMove={() => setSelectedIndex(index)}>
+          {itemDelegate(item$1, index === selectedIndex)}
+        </div>)}
+    </div>;
+}
+
+//#endregion
+//#region src/components/sdk.tsx
+const PropertyModelContext = React$1.createContext({});
+function usePropertyModel() {
+	return React$1.useContext(PropertyModelContext);
+}
+const ReferenceNestingContext = React$1.createContext([]);
+function useReferenceNesting() {
+	return React$1.useContext(ReferenceNestingContext);
+}
+const SDKSnippetLanguages = {
+	"node.default": {
+		name: "TypeScript",
+		icon: "typescript"
+	},
+	"typescript.default": {
+		name: "TypeScript",
+		icon: "typescript"
+	},
+	"python.default": {
+		name: "Python",
+		icon: "python"
+	},
+	"go.default": {
+		name: "Go",
+		icon: "go"
+	},
+	"java.default": {
+		name: "Java",
+		icon: "java"
+	},
+	"kotlin.default": {
+		name: "Kotlin",
+		icon: "kotlin"
+	},
+	"http.curl": {
+		name: "cURL",
+		icon: "http"
+	},
+	"http.powershell": {
+		name: "Powershell",
+		icon: "powershell"
+	},
+	"terraform.default": {
+		name: "Terraform",
+		icon: "terraform"
+	},
+	"ruby.default": {
+		name: "Ruby",
+		icon: "ruby"
+	}
+};
+function SDKChildren({ paths, expand, depth }) {
+	const Docs = useComponents();
+	return <div className={style_default.Properties}>
+      {paths.map((path, i) => <Docs.SDKDeclaration path={path} key={i} expand={expand} depth={depth} />)}
+    </div>;
+}
+function SDKDeclaration({ path, expand, depth = 0 }) {
+	const Lang = useLanguageComponents();
+	const Docs = useComponents();
+	const decl = useDeclaration(path, true);
+	const settings = useSettings();
+	const model = usePropertyModel();
+	const nesting = useReferenceNesting();
+	const { selectedPath } = useNavigation();
+	if (decl.kind.endsWith("Reference")) {
+		const refId = "type" in decl && typeof decl.type !== "string" && "$ref" in decl.type ? decl.type["$ref"] : void 0;
+		if (refId && refId !== path && !nesting.includes(refId)) return <ReferenceNestingContext.Provider value={[...nesting, refId]}>
+          <SDKDeclaration path={refId} expand={expand} depth={depth} />
+        </ReferenceNestingContext.Provider>;
+	}
+	const isUnion = "childrenParentSchema" in decl && decl.childrenParentSchema && ["enum", "union"].includes(decl.childrenParentSchema);
+	const id = model?.propertyPath ? `${model.propertyPath} + ${path}` : path;
+	const shouldExpand = selectedPath?.startsWith(path) && nesting.length < 1 || settings?.properties?.expandDepth && depth <= settings?.properties?.expandDepth && !isUnion || expand;
+	const content = <Lang.Property decl={decl}>
+      {({ ...props }) => <Docs.Property id={id} expand={shouldExpand} constraints={"constraints" in decl && <Docs.SDKConstraints constraints={decl["constraints"]} />} declaration={<Lang.Declaration decl={decl} />} description={"docstring" in decl ? decl["docstring"] : void 0} deprecated={decl.deprecated} {...props}>
+          {"children" in decl && (decl.children?.length ?? 0) > 0 && (settings?.properties?.includeModelProperties !== false || !("modelPath" in decl)) && <>
+                {isUnion && <div className={style_default.PropertyAnnotation}>Accepts one of the following:</div>}
+                <Docs.SDKChildren paths={decl.children ?? []} depth={depth + 1} />
+              </>}
+        </Docs.Property>}
+    </Lang.Property>;
+	if ("modelPath" in decl) {
+		const value = {
+			modelPath: decl.modelPath,
+			propertyPath: decl.stainlessPath
+		};
+		return <PropertyModelContext.Provider value={value}>{content}</PropertyModelContext.Provider>;
+	}
+	return content;
+}
+function SDKConstraints({ constraints }) {
+	if (constraints) return <div className={style_default.PropertyConstraints}>
+        {Object.entries(constraints).map(([name, value]) => <div className={style_default.PropertyConstraint} key={name}>
+            <span className={style_default.PropertyConstraintName}>{name}</span>
+            <span className={style_default.PropertyConstraintValue}>{value}</span>
+          </div>)}
+      </div>;
+}
+const snippetIcons = {
+	"node.default": TypescriptIcon,
+	"typescript.default": TypescriptIcon,
+	"go.default": GoIcon,
+	"python.default": PythonIcon,
+	"terraform.default": TerraformIcon,
+	"http.curl": CurlIcon,
+	"http.powershell": PowershellIcon,
+	"ruby.default": RubyIcon,
+	"java.default": JavaIcon,
+	"kotlin.default": KotlinIcon
+};
+function SDKIcon({ language }) {
+	const LangIcon = snippetIcons[language];
+	if (!LangIcon) return null;
+	return <LangIcon className={clsx(style_default.Icon, language.split(".").shift())} />;
+}
+function SDKRequestTitle({ snippetLanguage }) {
+	const languageName = SDKSnippetLanguages[snippetLanguage]?.name;
+	return <span className={style_default.SnippetRequestTitleLanguage}>
+      <SDKIcon language={snippetLanguage} /> {languageName}
+    </span>;
+}
+function SDKExample({ method, transformRequestSnippet }) {
+	const Docs = useComponents();
+	const snippetLanguage = getLanguageSnippet(useLanguage());
+	return <Docs.Snippet requestTitle={<Docs.SDKRequestTitle snippetLanguage={snippetLanguage} />} method={method} transformRequestSnippet={transformRequestSnippet} />;
+}
+function SDKMethodHeader({ method }) {
+	const Docs = useComponents();
+	const Lang = useLanguageComponents();
+	const decl = useDeclaration(method.stainlessPath, true);
+	return <Docs.MethodHeader level="h1" title={method.summary ?? method.title} signature={<Lang.MethodSignature decl={decl} />} badges={method.deprecated && <Docs.Badge id="deprecated">Deprecated</Docs.Badge>}>
+      <Docs.MethodRoute httpMethod={method.httpMethod} endpoint={method.endpoint.split(" ", 2).at(-1)} />
+    </Docs.MethodHeader>;
+}
+function SDKMethodInfo({ method }) {
+	const Docs = useComponents();
+	const Lang = useLanguageComponents();
+	const decl = useDeclaration(method.stainlessPath, true);
+	const spec = useSpec();
+	const language = useLanguage();
+	if (Lang.MethodInfo) return <Lang.MethodInfo decl={decl} />;
+	function shouldExpand(items) {
+		if (items.length > 1) return false;
+		const item$1 = items[0];
+		if (!item$1) return false;
+		const decl$1 = spec?.decls?.[language]?.[item$1];
+		return decl$1 && "children" in decl$1 && decl$1.children && decl$1.children.length > 0;
+	}
+	return <Docs.MethodInfo parameters={"paramsChildren" in decl && Array.isArray(decl.paramsChildren) && decl.paramsChildren.length > 0 && <Docs.SDKChildren expand={shouldExpand(decl.paramsChildren)} paths={decl.paramsChildren} />} returns={"responseChildren" in decl && decl.responseChildren && decl.responseChildren.length > 0 && <Docs.SDKChildren expand={shouldExpand(decl.responseChildren)} paths={decl.responseChildren} />} />;
+}
+function SDKMethod({ method, transformRequestSnippet }) {
+	const Docs = useComponents();
+	const decl = useDeclaration(method?.stainlessPath, true);
+	const layout = useContentPanelLayout();
+	if (!decl) return;
+	return <Docs.Method id={method.stainlessPath} header={<Docs.SDKMethodHeader method={method} />} className={clsx({
+		[style_default.MethodSinglePane]: layout === "single-pane",
+		[style_default.MethodDoublePane]: layout === "double-pane"
+	})}>
+      <div className={style_default.MethodContentColumn}>
+        <Docs.MethodDescription description={method.description} />
+        <Docs.SDKMethodInfo method={method} />
+      </div>
+      <div className={style_default.MethodExample + " not-content"}>
+        <Docs.SDKExample method={method} transformRequestSnippet={transformRequestSnippet} />
+      </div>
+      <div className={style_default.MethodResponseColumn}>
+        <h5>Returns Examples</h5>
+        <Docs.SnippetResponse responses={method.exampleResponses} />
+      </div>
+    </Docs.Method>;
+}
+function SDKModel({ model }) {
+	const Docs = useComponents();
+	if (!useDeclaration(`${model.stainlessPath} > (schema)`, true)) return null;
+	return <div className={style_default.Model} tabIndex={0}>
+      <div className={style_default.ResourceContentProperties}>
+        <Docs.SDKDeclaration path={`${model.stainlessPath} > (schema)`} />
+      </div>
+    </div>;
+}
+function SDKReference({ stainlessPath, children }) {
+	const Docs = useComponents();
+	if (!stainlessPath || !stainlessPath.endsWith("(schema)")) return children;
+	return <span className={style_default.TypeReference}>
+      <Docs.Link stainlessPath={stainlessPath}>{children}</Docs.Link>
+    </span>;
+}
+function SDKLanguageBlock({ language, version, install, links }) {
+	const Docs = useComponents();
+	const lang = `${language}.default`;
+	return <div className={style_default.LanguageBlock}>
+      <div className={style_default.LanguageBlockContent}>
+        <div className={style_default.LanguageBlockContentIcon}>
+          <Docs.SDKIcon language={lang} size={24} />
+        </div>
+        <div className={style_default.LanguageBlockContentInfo}>
+          <div className={style_default.LanguageBlockContentInfoLanguage}>{Docs.SDKSnippetLanguages[lang].name}</div>
+          <div className={style_default.LanguageBlockContentInfoVersion}>{version}</div>
+        </div>
+      </div>
+
+      <div className={style_default.LanguageBlockInstall} data-stldocs-copy-parent>
+        <pre data-stldocs-copy-content>{install}</pre>{" "}
+        <Button variant="ghost" size="sm" data-stldocs-snippet-copy>
+          <Copy size={16} className={style_default.Icon} />
+        </Button>
+      </div>
+
+      <div className={style_default.LanguageBlockLinks}>
+        <Button href={links.repo} variant="outline">
+          <Button.Icon icon={Github} />
+        </Button>
+        <Button href={links.docs} variant="outline">
+          <Button.Icon icon={BookOpen} />
+          <Button.Label>Read Docs</Button.Label>
+        </Button>
+      </div>
+    </div>;
+}
+
+//#endregion
+//#region src/components/snippets.tsx
+function SnippetCode({ content, language }) {
+	const lang = useLanguage();
+	const highlighted = useHighlight(content, language || lang);
+	return <div className={style_default.SnippetCode}>
+      <pre className={style_default.SnippetCodeContent} data-stldocs-copy-content>
+        <code className={language === "json" ? "snippet-json" : "snippet"} dangerouslySetInnerHTML={{ __html: highlighted }} />
+      </pre>
+    </div>;
+}
+function SnippetContainer({ children }) {
+	return <div className={clsx(style_default.Snippet)}>{children}</div>;
+}
+function SnippetRequestContainer({ children }) {
+	return <div>{children}</div>;
+}
+function Snippet({ requestTitle, method, transformRequestSnippet }) {
+	const Docs = useComponents();
+	const language = useLanguage();
+	const [CopyButtonIcon, setCopyIcon] = React$1.useState(CopyIcon);
+	const originalSnippet = useSnippet(method.stainlessPath, void 0, language === "http" ? "curl" : "default");
+	const decl = useDeclaration(method.stainlessPath, false);
+	if (!originalSnippet) {
+		console.warn(`Snippet not found for method '${method.stainlessPath}'`);
+		return null;
+	}
+	const signature = decl && "qualified" in decl ? decl.qualified : void 0;
+	const responses = method.exampleResponses;
+	const snippet = transformRequestSnippet ? transformRequestSnippet({
+		snippet: originalSnippet,
+		language
+	}) : originalSnippet;
+	async function handleCopy() {
+		try {
+			await navigator.clipboard.writeText(snippet);
+			setCopyIcon(CheckIcon);
+		} catch {
+			setCopyIcon(CircleAlertIcon);
+		}
+		setTimeout(() => setCopyIcon(CopyIcon), 1e3);
+	}
+	return <Docs.SnippetContainer signature={signature}>
+      {snippet && <Docs.SnippetRequestContainer signature={signature}>
+          <div className={style_default.SnippetRequest} data-stldocs-copy-parent>
+            <div className={style_default.SnippetRequestTitle}>
+              <div className={style_default.SnippetRequestTitleMethod}>
+                <Docs.MethodRoute httpMethod={method.httpMethod} iconOnly />
+                <h5>{method.summary}</h5>
+              </div>
+              <div className={style_default.SnippetRequestTitleContent}>{requestTitle}</div>
+              <Button variant="ghost" data-stldocs-snippet-copy>
+                <CopyButtonIcon size={16} className={style_default.Icon} onClick={handleCopy} />
+              </Button>
+            </div>
+            <Docs.SnippetCode content={snippet} signature={signature} />
+          </div>
+        </Docs.SnippetRequestContainer>}
+      {responses && <Docs.SnippetResponse responses={responses} />}
+    </Docs.SnippetContainer>;
+}
+function SnippetResponse({ responses }) {
+	const { SnippetCode: SnippetCode$1 } = useComponents();
+	if (!responses) return null;
+	const mappedResponses = Object.keys(responses).map((key) => {
+		const responseContent = responses[key];
+		if (!responseContent) return null;
+		const responseType = Object.keys(responseContent)[0];
+		if (!responseType) return null;
+		const response = responseContent[responseType];
+		if (!response) return null;
+		const examples = response?.examples;
+		if (!examples) return null;
+		const exampleType = Object.keys(examples)[0];
+		if (!exampleType) return null;
+		let value = examples[exampleType]?.value;
+		if (!value) return null;
+		if (responseType === "application/json") value = JSON.stringify(value, null, 2);
+		return {
+			responseCode: key,
+			content: value
+		};
+	}).filter(Boolean);
+	if (mappedResponses.length === 0) return null;
+	return <div className={style_default.SnippetMultiResponse}>
+      <div className={clsx(style_default.Snippet)}>
+        <div className={clsx(style_default.SnippetResponseTab, mappedResponses.length === 1 && style_default.SnippetResponseTabSingleReturn)}>
+          {mappedResponses.map(({ responseCode }, index) => <button className={clsx(style_default.SnippetResponseTabItem, index === 0 && style_default.SnippetResponseTabItemActive)} key={`snippet-response-tab-item-${responseCode}-${index}`} data-snippet-response-tab-id={`snippet-response-tab-${responseCode}-${index}`} disabled={mappedResponses.length === 1}>
+              {responseCode} example
+            </button>)}
+        </div>
+        {mappedResponses.map(({ responseCode, content }, index) => {
+		return <div className={clsx(style_default.SnippetResponsePane, index === 0 && style_default.SnippetResponsePaneActive)} key={`snippet-response-${responseCode}-${index}`} data-snippet-response-pane-id={`snippet-response-tab-${responseCode}-${index}`}>
+              <SnippetCode$1 content={content} language="json" />
+            </div>;
+	})}
+      </div>
+    </div>;
+}
+
+//#endregion
+//#region src/components/overview.tsx
+function SDKResourceHeader({ resource, parents }) {
+	const segments = parents?.map((parent, index) => <span className={style_default.ResourceTitleSegment} key={parent.stainlessPath}>
+      {parent.title}
+      {index < parents.length && <ChevronRight size={16} className={style_default.Icon} />}
+    </span>);
+	if (!segments && !resource.description) return null;
+	return <div className={style_default.ResourceHeader}>
+      {segments && <h4 id={resource.stainlessPath} className={style_default.ResourceTitle}>
+          {segments}
+          <span className={style_default.ResourceTitleSegment}>{resource.title}</span>
+        </h4>}
+      {resource.description && <div className={style_default.ResourceDescription}>
+          <Markdown content={resource.description} />
+        </div>}
+    </div>;
+}
+function SDKMethodSummary({ method }) {
+	const Docs = useComponents();
+	const Lang = useLanguageComponents();
+	const decl = useDeclaration(method.stainlessPath, true);
+	return <Docs.MethodHeader level="h5" title={<Docs.Link stainlessPath={method.stainlessPath}>{method.summary ?? method.title}</Docs.Link>} signature={<Lang.MethodSignature decl={decl} />} badges={method.deprecated && <Docs.Badge id="deprecated">Deprecated</Docs.Badge>}>
+      <Docs.MethodRoute httpMethod={method.httpMethod} endpoint={method.endpoint.split(" ", 2).at(-1)} />
+      {}
+      {}
+    </Docs.MethodHeader>;
+}
+function SDKResource({ resource, parents, showModels }) {
+	const Docs = useComponents();
+	const language = useLanguage();
+	const spec = useSpec();
+	const methods = Object.values(resource.methods).filter((method) => spec?.decls?.[language]?.[method.stainlessPath]);
+	const models = Object.values(resource.models).filter((model) => spec?.decls?.[language]?.[`${model.stainlessPath} > (schema)`]);
+	return <div className={style_default.Resource}>
+      <div className={style_default.ResourceContent}>
+        <Docs.SDKResourceHeader resource={resource} parents={parents} />
+        {methods.length > 0 && <div className={style_default.ResourceContentGroup}>
+            {methods.map((method) => <div className={style_default.MethodSummary} key={method.stainlessPath}>
+                <Docs.SDKMethodSummary method={method} />
+              </div>)}
+          </div>}
+
+        {showModels !== false && models.length > 0 && <div className={style_default.ResourceContentGroup} data-stldocs-property-group="models">
+            <h5 className={style_default.ResourceContentGroupModelTitle}>
+              Models
+              <PropertyToggle target="models" />
+            </h5>
+            {models.map((model) => <Docs.SDKModel model={model} key={model.stainlessPath} />)}
+          </div>}
+      </div>
+    </div>;
+}
+function SDKOverview({ resource }) {
+	const { SDKResource: SDKResource$1 } = useComponents();
+	const nested = React$1.useMemo(() => flatResources(resource.subresources, [resource]), [resource]);
+	return <div className={style_default.Overview}>
+      <div className={style_default.OverviewHeader}>
+        <h1>{resource.title}</h1>
+      </div>
+      <SDKResource$1 resource={resource} />
+      {nested.map((props, index) => <SDKResource$1 {...props} key={index} />)}
+    </div>;
+}
+function SDKRoot({ stainlessPath }) {
+	const spec = useSpec();
+	const Docs = useComponents();
+	const parsed = parseStainlessPath(stainlessPath);
+	const resource = spec && getResourceFromSpec(stainlessPath, spec);
+	if (!resource || !parsed) {
+		console.warn(`Could not find resource or parsed path for '${stainlessPath}'`);
+		return null;
+	}
+	if (parsed.method) {
+		const method = resource.methods[parsed.method];
+		if (!method) {
+			console.warn(`Method '${parsed.method}' not found in resource '${resource.stainlessPath}'`);
+			return null;
+		}
+		return <div className={style_default.Root}>
+        <Docs.SDKMethod method={method} />
+      </div>;
+	}
+	return <div className={style_default.Root}>
+      <Docs.SDKOverview resource={resource} />
+    </div>;
+}
+
+//#endregion
+//#region src/components/breadcrumbs.tsx
+function generateApiBreadcrumbs(fullPath, spec, basePath) {
+	const cleanBasePath = basePath.replace(/\/+$/, "");
+	const cleanPath = fullPath.replace(/\/+$/, "");
+	if (!cleanPath.startsWith(cleanBasePath)) return null;
+	const rest = cleanPath.slice(cleanBasePath.length).split("/").filter(Boolean);
+	const breadcrumbs = [];
+	let href = cleanBasePath;
+	let i = 0;
+	if (Languages.includes(rest[0])) {
+		href += `/${rest[0]}`;
+		i++;
+	}
+	breadcrumbs.push({
+		title: "API Reference",
+		href
+	});
+	let currentSpec = spec;
+	while (i < rest.length) {
+		const idType = rest[i];
+		const idValue = rest[i + 1];
+		if (!idType || !idValue || !currentSpec?.[idType]?.[idValue]) break;
+		currentSpec = currentSpec[idType][idValue];
+		href += `/${idType}/${idValue}`;
+		const title = (idType === "methods" ? currentSpec.summary : currentSpec.title) ?? idValue;
+		breadcrumbs.push({
+			title,
+			href
+		});
+		i += 2;
+	}
+	return breadcrumbs;
+}
+function SDKBreadcrumbs({ spec, currentPath, basePath = "/api", config = { includeCurrentPage: false } }) {
+	const breadcrumbs = generateApiBreadcrumbs(currentPath, spec, basePath);
+	if (!breadcrumbs || breadcrumbs.length === 0) return null;
+	if (!config?.includeCurrentPage && breadcrumbs.length > 1) breadcrumbs.pop();
+	const items = breadcrumbs.map((crumb, index) => <div key={index} className={style_default.BreadcrumbsItem}>
+      <a href={crumb.href} className={style_default.BreadcrumbsLink}>
+        {crumb.title}
+      </a>
+    </div>);
+	return <div className={style_default.Breadcrumbs}>
+      <Join limit={breadcrumbs.length} items={items}>
+        <ChevronRight />
+      </Join>
+    </div>;
+}
+
+//#endregion
+//#region src/components/sidebar.tsx
+function SidebarExpander({ open, summary, children }) {
+	return <details className={style_default.SidebarExpander} open={open}>
+      <summary className={style_default.ExpanderSummary}>
+        <div className={style_default.ExpanderSummaryContent}>{summary}</div>
+        <div className={style_default.ExpanderSummaryIcon}>
+          <ChevronRight size={16} strokeWidth={1} className={style_default.Icon} />
+          <ChevronDown size={16} strokeWidth={1} className={style_default.Icon} />
+        </div>
+      </summary>
+      <div className={style_default.ExpanderContent}>{children}</div>
+    </details>;
+}
+function SidebarMethod({ method }) {
+	const Docs = useComponents();
+	const { selectedPath } = useNavigation();
+	return <div className={style_default.SidebarMethod} data-selected={method.stainlessPath === selectedPath}>
+      <MethodIconBadge httpMethod={method.httpMethod} />
+      <Docs.Link stainlessPath={method.stainlessPath}>{method.summary}</Docs.Link>
+    </div>;
+}
+function SidebarResource({ resource }) {
+	const Docs = useComponents();
+	const { selectedPath } = useNavigation();
+	const subresources = Object.values(resource.subresources ?? {}).map((sub) => <SidebarResource resource={sub} key={sub.stainlessPath} />);
+	const methods = Object.values(resource.methods).map((method) => <SidebarMethod method={method} key={method.stainlessPath} />);
+	const hasChildren = subresources.length > 0 || methods.length > 0;
+	const title = <div className={style_default.SidebarResourceTitle}>
+      <Docs.Link stainlessPath={resource.stainlessPath}>{resource.title}</Docs.Link>
+    </div>;
+	return <div className={style_default.SidebarResource} data-selected={resource.stainlessPath === selectedPath}>
+      {hasChildren ? <SidebarExpander summary={title} open={true}>
+          {methods}
+          {subresources}
+        </SidebarExpander> : title}
+    </div>;
+}
+function Sidebar({ resources }) {
+	return <div className={`${style_default.Root} ${style_default.Sidebar}`}>
+      {resources.filter((resource) => !isResourceEmpty(resource)).map((resource) => <SidebarResource resource={resource} key={resource.stainlessPath} />)}
+    </div>;
+}
+
+//#endregion
+//#region src/components/index.ts
+var components_exports = /* @__PURE__ */ __export({
+	Badge: () => Badge,
+	Dropdown: () => Dropdown,
+	DropdownItem: () => DropdownItem,
+	DropdownMenu: () => DropdownMenu,
+	DropdownTrigger: () => DropdownTrigger,
+	Expander: () => Expander,
+	HttpMethodIcons: () => HttpMethodIcons,
+	HttpMethods: () => HttpMethods,
+	Input: () => Input,
+	Join: () => Join,
+	Link: () => Link,
+	ListView: () => ListView,
+	Markdown: () => Markdown,
+	Method: () => Method,
+	MethodDescription: () => MethodDescription,
+	MethodHeader: () => MethodHeader,
+	MethodIconBadge: () => MethodIconBadge,
+	MethodInfo: () => MethodInfo$1,
+	MethodRoute: () => MethodRoute,
+	Property: () => Property$6,
+	PropertyDescription: () => PropertyDescription,
+	PropertyModelContext: () => PropertyModelContext,
+	PropertyToggle: () => PropertyToggle,
+	ReferenceNestingContext: () => ReferenceNestingContext,
+	SDKBreadcrumbs: () => SDKBreadcrumbs,
+	SDKChildren: () => SDKChildren,
+	SDKConstraints: () => SDKConstraints,
+	SDKDeclaration: () => SDKDeclaration,
+	SDKExample: () => SDKExample,
+	SDKIcon: () => SDKIcon,
+	SDKLanguageBlock: () => SDKLanguageBlock,
+	SDKMethod: () => SDKMethod,
+	SDKMethodHeader: () => SDKMethodHeader,
+	SDKMethodInfo: () => SDKMethodInfo,
+	SDKMethodSummary: () => SDKMethodSummary,
+	SDKModel: () => SDKModel,
+	SDKOverview: () => SDKOverview,
+	SDKReference: () => SDKReference,
+	SDKRequestTitle: () => SDKRequestTitle,
+	SDKResource: () => SDKResource,
+	SDKResourceHeader: () => SDKResourceHeader,
+	SDKRoot: () => SDKRoot,
+	SDKSnippetLanguages: () => SDKSnippetLanguages,
+	Sidebar: () => Sidebar,
+	SidebarExpander: () => SidebarExpander,
+	SidebarMethod: () => SidebarMethod,
+	SidebarResource: () => SidebarResource,
+	Snippet: () => Snippet,
+	SnippetCode: () => SnippetCode,
+	SnippetContainer: () => SnippetContainer,
+	SnippetRequestContainer: () => SnippetRequestContainer,
+	SnippetResponse: () => SnippetResponse,
+	ToggleButton: () => ToggleButton,
+	Tooltip: () => Tooltip,
+	VirtualExpander: () => VirtualExpander,
+	usePropertyModel: () => usePropertyModel,
+	useReferenceNesting: () => useReferenceNesting
+});
+
+//#endregion
+//#region src/languages/typescript.tsx
+var typescript_exports = /* @__PURE__ */ __export({
+	Declaration: () => Declaration$5,
+	MethodSignature: () => MethodSignature$5,
+	Property: () => Property$5,
+	Type: () => Type$5,
+	TypeName: () => TypeName$5
+});
+const ComplexTypes$3 = {
+	TSTypeObject: "object",
+	TSTypeUnion: "union",
+	TSTypeInterface: "interface",
+	TSTypeIntersection: "intersection",
+	TSTypeArray: "array"
+};
+const constStyle$3 = {
+	string: style_default.LiteralString,
+	number: style_default.LiteralNumeric,
+	boolean: style_default.LiteralBoolean
+};
+function Identifier$1({ name, optional }) {
+	return <>
+      <span className={style_default.TextIdentifier}>
+        {/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(name) ? name : JSON.stringify(name)}
+      </span>
+      {optional && <span className={style_default.TextPunctuation}>?</span>}
+    </>;
+}
+function TypeParams({ params }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1 } = useComponents();
+	if (!params?.length) return null;
+	const typeParams = params?.map((param, key) => param.constraint ? <React$1.Fragment key={key}>
+        <span className={style_default.TypeReference}>{param.name}</span>
+        <span className={style_default.TextKeyword}>extends </span>
+        <Lang.Type type={param.constraint} />
+      </React$1.Fragment> : <React$1.Fragment key={key}>param.name</React$1.Fragment>);
+	return <>
+      <span className={style_default.TypeBracket}>{"<"}</span>
+      <Join$1 items={typeParams} limit={3}>
+        <span className={style_default.TextOperator}>, </span>
+      </Join$1>
+      <span className={style_default.TypeBracket}>{">"}</span>
+    </>;
+}
+function TypePreview$2({ path }) {
+	const spec = useSpec();
+	const language = useLanguage();
+	const decl = useDeclaration(path, false);
+	const { Join: Join$1 } = useComponents();
+	if (!(decl && "children" in decl && decl.children && decl.children.length > 0) || decl && "type" in decl && "kind" in decl["type"] && decl["type"]["kind"] === "TSTypeUnion") return;
+	const items = decl.children.map((prop, key) => {
+		const p = spec?.decls?.[language]?.[prop];
+		return <span key={key} className={style_default.TypePropertyName}>
+        <span className={style_default.TextIdentifier}>{p && "key" in p ? p["key"] : null}</span>
+      </span>;
+	});
+	return <span className={style_default.TypePreview} data-stldocs-type-preview="properties">
+      <span className={style_default.TypeBrace}>{" {"}</span>
+      <span className={style_default.TypePreviewContent}>
+        {" "}
+        <Join$1 items={items} limit={3}>
+          <span className={style_default.TextOperator}>, </span>
+        </Join$1>{" "}
+      </span>
+      <span className={style_default.TypeBrace}>{"} "}</span>
+    </span>;
+}
+function TypeName$5({ type }) {
+	const Lang = useLanguageComponents();
+	return ComplexTypes$3[type.kind] ?? <Lang.Type type={type} />;
+}
+function Type$5({ type }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1, SDKReference: SDKReference$1 } = useComponents();
+	switch (type.kind) {
+		case "TSTypeUnknown":
+		case "TSTypeUndefined":
+		case "TSTypeNever":
+		case "TSTypeVoid":
+		case "TSTypeNull":
+		case "TSTypeAny":
+		case "TSTypeBoolean":
+		case "TSTypeNumber": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{type.kind.slice(6).toLowerCase()}</span>
+        </span>;
+		case "TSTypeString": return <span className={style_default.Type}>
+          <span className={style_default.TypeString}>string</span>
+        </span>;
+		case "TSTypeLiteral": return <span className={style_default.Type}>
+          <span className={constStyle$3[typeof type.literal]}>{JSON.stringify(type.literal)}</span>
+        </span>;
+		case "TSTypeArray": return <span className={style_default.Type}>
+          <span className={style_default.TypeArray}>{"Array<"}</span>
+          <Lang.Type type={type.elementType} />
+          <span className={style_default.TypeArray}>{">"}</span>
+        </span>;
+		case "TSTypeReference": {
+			const name = type.ident.split(".").at(-1);
+			const params = type.typeParameters?.map((param, key) => <Lang.Type key={key} type={param} />);
+			return <span className={style_default.Type}>
+          <SDKReference$1 stainlessPath={type.$ref}>{name}</SDKReference$1>
+          {params && params.length > 0 && <>
+              <span className={style_default.TypeBracket}>{"<"}</span>
+              <Join$1 items={params} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+              <span className={style_default.TypeBracket}>{">"}</span>
+            </>}
+          <TypePreview$2 path={type.$ref} />
+        </span>;
+		}
+		case "TSTypeIntersection":
+		case "TSTypeUnion": {
+			const items = type.types.map((t, key) => <Lang.Type key={key} type={t} />);
+			const delimiter = type.kind === "TSTypeUnion" ? "|" : "&";
+			return <span className={style_default.Type}>
+          <span className={style_default.TypePreview} data-stldocs-type-preview="union">
+            <span className={style_default.TypePreviewContent}>
+              <Join$1 items={items} limit={3}>
+                <span className={style_default.TextOperator}> {delimiter} </span>
+              </Join$1>
+            </span>
+          </span>
+        </span>;
+		}
+		case "TSTypeObject":
+		case "TSTypeInterface": {
+			const extend = type.kind === "TSTypeObject" ? null : type.extends?.map((ref, key) => <Lang.Type key={key} type={ref} />);
+			const items = type.members.map((prop, key) => <React$1.Fragment key={key}>
+          <span className={style_default.TypePropertyName}>
+            <Identifier$1 name={prop.ident} optional={prop.optional} />
+          </span>
+          <span className={style_default.TextPunctuation}>: </span>
+          <Lang.Type type={prop.type} />
+        </React$1.Fragment>);
+			return <span className={style_default.Type}>
+          {extend?.length && <>
+              <span className={style_default.TypeKeyword}> extends </span>
+              <Join$1 items={extend} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+            </>}
+          <span className={style_default.TypePreview} data-stldocs-type-preview="properties">
+            <span className={style_default.TypeBrace}>{"{ "}</span>
+            <span className={style_default.TypePreviewContent}>
+              <Join$1 items={items} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+            </span>
+            <span className={style_default.TypeBrace}>{"} "}</span>
+          </span>
+        </span>;
+		}
+	}
+}
+function MethodSignature$5({ decl }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1, Tooltip: Tooltip$1 } = useComponents();
+	const params = decl.signature.parameters.map((param, i) => <React$1.Fragment key={i}>
+      <Tooltip$1 content={<Lang.Type type={param.type} />}>
+        <span className={style_default.TextIdentifier}>{param.ident}</span>
+      </Tooltip$1>
+      {param.optional && <span className={style_default.TextPunctuation}>?</span>}
+    </React$1.Fragment>);
+	return <div className={style_default.MethodSignature}>
+      <span className={style_default.SignatureTitle}>
+        {decl.signature.async && <span className={style_default.TextKeyword}>async </span>}
+        <span className={style_default.SignatureQualified}>
+          <span className={style_default.TextIdentifier}>{decl.qualified?.slice(0, -decl.ident.length)}</span>
+        </span>
+        <span className={style_default.SignatureName}>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+        </span>
+        <span className={style_default.MethodSignature}>
+          {decl.signature.typeParameters && <TypeParams params={decl.signature.typeParameters} />}
+          <span className={style_default.SignatureParen}>{"("}</span>
+
+          <span className={style_default.SignatureParams}>
+            <Join$1 items={params}>
+              <span className={style_default.TextOperator}>{", "}</span>
+            </Join$1>
+          </span>
+
+          <span className={style_default.SignatureParen}>{")"}</span>
+          {decl.signature.returns && <>
+              <span className={style_default.TextPunctuation}>: </span>
+              <Lang.Type type={decl.signature.returns} />
+            </>}
+        </span>
+      </span>
+    </div>;
+}
+function Property$5({ decl, children }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "TSDeclProperty": return children({
+			name: decl.key,
+			typeName: <Lang.TypeName type={decl.type} />,
+			type: decl.type.kind in ComplexTypes$3 && <Lang.Type type={decl.type} />
+		});
+		case "TSDeclTypeAlias": return children({
+			name: decl.ident,
+			typeName: "alias",
+			type: <Lang.Type type={decl.type} />
+		});
+		case "TSDeclReference": return children({ type: <Lang.Type type={decl.type} /> });
+		case "TSDeclInterface": return children({ type: <>
+            <span className={style_default.TextIdentifier}>{decl.ident}</span>
+            {decl.typeParameters && <TypeParams params={decl.typeParameters} />}
+            {decl.extends?.flatMap((t, key) => <React$1.Fragment key={`extends:${key}`}>
+                <span className={style_default.TextKeyword}> extends </span>
+                <Lang.Type type={t} />
+              </React$1.Fragment>)}
+          </> });
+	}
+}
+function Declaration$5({ decl }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "TSDeclProperty": return <>
+          {decl.declare && <span className={style_default.TextKeyword}>declare </span>}
+          <span className={style_default.TypePropertyName}>
+            <Identifier$1 name={decl.key} optional={decl.optional} />
+          </span>
+          <span className={style_default.TextPunctuation}>: </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "TSDeclFunction": return <Lang.MethodSignature decl={decl} />;
+		case "TSDeclTypeAlias": return <>
+          <Identifier$1 name={decl.ident} />
+          <TypeParams params={decl.typeParameters} />
+          <span className={style_default.TextOperator}> = </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "TSDeclReference": return <Lang.Type type={decl.type} />;
+		case "TSDeclInterface": return <>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          <TypeParams params={decl.typeParameters} />
+          {decl.extends?.map((t, index) => <React$1.Fragment key={index}>
+              <span className={style_default.TextKeyword}> extends </span>
+              <Lang.Type type={t} />
+            </React$1.Fragment>)}
+          <TypePreview$2 path={decl.stainlessPath} />
+        </>;
+		case "TSDeclClass": return <>
+          <span className={style_default.TextKeyword}>class </span>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          <TypeParams params={decl.typeParameters} />
+          {decl.superClass ? <>
+              <span className={style_default.TextKeyword}> extends </span>
+              <Lang.Type type={decl.superClass} />
+            </> : null}
+          {decl.implements?.map((t, index) => <React$1.Fragment key={index}>
+              <span className={style_default.TextKeyword}> implements </span>
+              <Lang.Type type={t} />
+            </React$1.Fragment>)}
+        </>;
+	}
+}
+
+//#endregion
+//#region src/languages/java.tsx
+var java_exports = /* @__PURE__ */ __export({
+	Declaration: () => Declaration$4,
+	MethodSignature: () => MethodSignature$4,
+	Property: () => Property$4,
+	Type: () => Type$4,
+	TypeName: () => TypeName$4
+});
+function showFullType$1(type) {
+	return type.kind === "JavaTypeReference" && (type.typeName === "List" || type.typeParameters && type.typeParameters.length > 0);
+}
+const constStyle$2 = {
+	string: style_default.LiteralString,
+	number: style_default.LiteralNumeric,
+	boolean: style_default.LiteralBoolean
+};
+function TypeName$4({ type, optional }) {
+	const Lang = useLanguageComponents();
+	if (type.kind === "JavaTypeReference" && type.typeName === "List") return "List";
+	return <Lang.Type type={type} optional={optional} />;
+}
+function Type$4({ type, optional }) {
+	const language = useLanguage();
+	const Lang = useLanguageComponents();
+	const { Join: Join$1, SDKReference: SDKReference$1 } = useComponents();
+	switch (type.kind) {
+		case "JavaTypeReference": {
+			const name = type.typeName.split(".").at(-1);
+			const params = type.typeParameters?.map((param, key) => <Lang.Type key={key} type={param} optional={optional} />);
+			return <span className={style_default.Type}>
+          <SDKReference$1 stainlessPath={type.$ref}>{name}</SDKReference$1>
+          {params && params.length > 0 ? <>
+              <span className={style_default.TypeBracket}>{"<"}</span>
+              <Join$1 items={params} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+              <span className={style_default.TypeBracket}>{">"}</span>
+            </> : null}
+        </span>;
+		}
+		case "JavaTypeClass":
+		case "JavaTypeUnion": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>class</span>
+        </span>;
+		case "JavaTypeEnum": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{language === "kotlin" ? "enum class" : "enum"}</span>
+        </span>;
+		case "JavaTypeVoid": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{language === "kotlin" ? "Nothing?" : "Void"}</span>
+        </span>;
+		case "JavaTypeBoolean": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>
+            {language === "kotlin" || optional ? "Boolean" : "boolean"}
+          </span>
+        </span>;
+		case "JavaTypeDouble": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{language === "kotlin" || optional ? "Double" : "double"}</span>
+        </span>;
+		case "JavaTypeLong": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{language === "kotlin" || optional ? "Long" : "long"}</span>
+        </span>;
+		case "JavaTypeString": return <span className={style_default.Type}>
+          <span className={style_default.TypeString}>String</span>
+        </span>;
+		case "JavaTypeConstant": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>JsonValue</span>;
+        </span>;
+	}
+}
+function MethodSignature$4({ decl }) {
+	const Lang = useLanguageComponents();
+	const language = useLanguage();
+	const { Join: Join$1, Tooltip: Tooltip$1 } = useComponents();
+	const params = decl.parameters.map((param, i) => <React$1.Fragment key={i}>
+      <Tooltip$1 content={<Lang.Type type={param.typeAnnotation} />}>
+        <span className={style_default.TextIdentifier}>{param.ident}</span>
+        {param.hasDefault && <>
+            {" "}
+            <span className={style_default.TextOperator}>=</span> <Lang.Type type={param.typeAnnotation} />
+            <span className={style_default.TextOperator}>.</span>
+            <span className={style_default.TextIdentifier}>none</span>
+            <span className={style_default.TextOperator}>()</span>
+          </>}
+      </Tooltip$1>
+    </React$1.Fragment>);
+	return <div className={style_default.MethodSignature}>
+      <span className={style_default.SignatureTitle}>
+        {decl.returnType && language !== "kotlin" && <span className={style_default.SignatureReturns}>
+            <Lang.Type type={decl.returnType} />{" "}
+          </span>}
+        {decl.qualified && <span className={style_default.SignatureQualified}>
+            <span className={style_default.TextIdentifier}>{decl.qualified?.slice(0, -decl.ident.length)}</span>
+          </span>}
+        <span className={style_default.SignatureName}>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+        </span>
+        <span className={style_default.MethodSignature}>
+          <span className={style_default.SignatureParen}>{"("}</span>
+
+          <span className={style_default.SignatureParams}>
+            <Join$1 items={params}>
+              <span className={style_default.TextOperator}>{", "}</span>
+            </Join$1>
+          </span>
+
+          <span className={style_default.SignatureParen}>{")"} </span>
+          {decl.returnType && language === "kotlin" && <>
+              <span className={style_default.TextOperator}>:</span> <Lang.Type type={decl.returnType} />
+            </>}
+        </span>
+      </span>
+    </div>;
+}
+function Property$4({ decl, children }) {
+	const Docs = useComponents();
+	const Lang = useLanguageComponents();
+	const language = useLanguage();
+	if (!decl) return null;
+	switch (decl.kind) {
+		case "JavaDeclProperty": {
+			const typeRaw = <Lang.Type type={decl.type} optional={decl.optional} />;
+			const typeWrapped = decl.optional ? <>
+          <span className={style_default.TypeKeyword}>Optional</span>
+          <span className={style_default.TypeBracket}>{"<"}</span>
+          {typeRaw}
+          <span className={style_default.TypeBracket}>{">"}</span>
+        </> : typeRaw;
+			const badges = <>
+          {decl.type.kind === "JavaTypeConstant" && <Docs.Tooltip content={<span className={style_default.TextIdentifier}>{decl.type.value}</span>}>
+              <span className={style_default.TextIdentifier}>constant</span>
+            </Docs.Tooltip>}
+        </>;
+			return children({
+				name: decl.ident,
+				typeName: <Lang.TypeName type={decl.type} optional={decl.optional} />,
+				type: showFullType$1(decl.type) && typeWrapped,
+				badges
+			});
+		}
+		case "JavaDeclConst": return children({
+			name: decl.ident,
+			typeName: "const",
+			type: <span className={constStyle$2[typeof decl.value]}>{JSON.stringify(decl.value)}</span>
+		});
+		case "JavaDeclType": {
+			const typeName$1 = decl.type.kind === "JavaTypeUnion" ? "union" : decl.type.kind === "JavaTypeEnum" ? language === "kotlin" ? "enum class" : "enum" : "class";
+			return children({
+				name: decl.ident,
+				typeName: typeName$1
+			});
+		}
+		case "JavaDeclReference": return children({ type: <Lang.Type type={decl.type} /> });
+	}
+}
+function Declaration$4({ decl }) {
+	const Docs = useComponents();
+	const Lang = useLanguageComponents();
+	const language = useLanguage();
+	if (!decl) return null;
+	switch (decl.kind) {
+		case "JavaDeclConst": return <>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          <span className={style_default.TextPunctuation}>{"("}</span>
+          {JSON.stringify(decl.value)}
+          <span className={style_default.TextPunctuation}>{")"}</span>
+        </>;
+		case "JavaDeclType": {
+			const keyword = decl.type.kind === "JavaTypeEnum" ? language === "kotlin" ? "enum class" : "enum" : "class";
+			return <>
+          <span className={style_default.TextKeyword}>{keyword}</span>{" "}
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          <span className={style_default.TextPunctuation}>:</span>
+          {decl.type.kind === "JavaTypeUnion" && <>
+              {" "}
+              <Docs.Tooltip content="A class that can be one of several variants.">
+                <Docs.Badge id="java-union">union</Docs.Badge>
+              </Docs.Tooltip>{" "}
+            </>}
+        </>;
+		}
+		case "JavaDeclProperty": {
+			const inlineType = <Lang.Type type={decl.type} optional={decl.optional} />;
+			const ident = <span className={style_default.TypePropertyName}>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+        </span>;
+			const suffix = decl.type.kind === "JavaTypeConstant" ? <>
+            {" "}
+            <Docs.Tooltip content={<span className={style_default.TextIdentifier}>{decl.type.value}</span>}>
+              <Docs.Badge id="java-constant">constant</Docs.Badge>
+            </Docs.Tooltip>
+          </> : null;
+			if (language === "kotlin") return <>
+            {ident}
+            <span className={style_default.TextPunctuation}>:</span>{" "}
+            {decl.optional ? <>
+                <span className={style_default.TypeReference}>Optional</span>
+                <span className={style_default.TypeBracket}>{"<"}</span>
+                {inlineType}
+                <span className={style_default.TypeBracket}>{">"}</span>
+              </> : inlineType}
+            {suffix}
+          </>;
+			return <>
+          {decl.optional ? <>
+              <span className={style_default.TypeReference}>Optional</span>
+              <span className={style_default.TypeBracket}>{"<"}</span>
+              {inlineType}
+              <span className={style_default.TypeBracket}>{">"}</span>
+            </> : inlineType}{" "}
+          {ident}
+          {suffix}
+        </>;
+		}
+		case "JavaDeclReference": return <Lang.Type type={decl.type} />;
+	}
+}
+
+//#endregion
+//#region src/languages/go.tsx
+var go_exports = /* @__PURE__ */ __export({
+	Declaration: () => Declaration$3,
+	MethodSignature: () => MethodSignature$3,
+	Property: () => Property$3,
+	Type: () => Type$3,
+	TypeName: () => TypeName$3
+});
+const ComplexTypes$2 = {
+	GoTypeMap: "map",
+	GoTypeArray: "array"
+};
+const Keywords$1 = {
+	GoTypeAny: "any",
+	GoTypeUnknown: "unknown",
+	GoTypeInt: "int64",
+	GoTypeFloat: "float64",
+	GoTypeBool: "bool",
+	GoTypeError: "error"
+};
+function isField(type) {
+	return type.kind === "GoTypeReference" && type.typeName === "param.Field";
+}
+function TypeName$3({ type }) {
+	const Lang = useLanguageComponents();
+	return isField(type) ? "field" : ComplexTypes$2[type.kind] ?? <Lang.Type type={type} />;
+}
+function Type$3({ type }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1, SDKReference: SDKReference$1 } = useComponents();
+	switch (type.kind) {
+		case "GoTypeReference": {
+			const params = type.typeParameters?.map((param, key) => <Lang.Type key={key} type={param} />);
+			return <span className={style_default.Type}>
+          {type.$ref ? <SDKReference$1 stainlessPath={type.$ref}>{type.typeName}</SDKReference$1> : type.typeName}
+          {params && params.length > 0 ? <>
+              <span className={style_default.TypeBracket}>{"["}</span>
+              <Join$1 items={params} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+              <span className={style_default.TypeBracket}>{"]"}</span>
+            </> : null}
+        </span>;
+		}
+		case "GoTypeAny":
+		case "GoTypeUnknown":
+		case "GoTypeInt":
+		case "GoTypeFloat":
+		case "GoTypeBool":
+		case "GoTypeError": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{Keywords$1[type.kind]}</span>
+        </span>;
+		case "GoTypeString": return <span className={style_default.Type}>
+          <span className={style_default.TypeString}>string</span>
+        </span>;
+		case "GoTypeArray": return <span className={style_default.Type}>
+          <span className={style_default.TextOperator}>[]</span>
+          <Lang.Type type={type.elementType} />
+        </span>;
+		case "GoTypeStruct": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{"struct{…}"}</span>
+        </span>;
+		case "GoTypeInterface": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{"interface{…}"}</span>
+        </span>;
+		case "GoTypeMap": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>map</span>
+          <span className={style_default.TypeBracket}>[</span>
+          <Lang.Type type={type.indexType} />
+          <span className={style_default.TextPunctuation}>,</span> <Lang.Type type={type.itemType} />
+          <span className={style_default.TypeBracket}>]</span>
+        </span>;
+		case "GoTypePointer": return <span className={style_default.Type}>
+          <span className={style_default.TextOperator}>*</span>
+          <Lang.Type type={type.inner} />
+        </span>;
+	}
+}
+function MethodSignature$3({ decl }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1 } = useComponents();
+	const params = decl.parameters.map((param, i) => <React$1.Fragment key={i}>
+      <span className={style_default.TextIdentifier}>{param.ident}</span>
+      {param.optional && <span className={style_default.TextPunctuation}>?</span>}
+    </React$1.Fragment>);
+	const returns = decl.returnType.map((t, key) => <Lang.Type key={key} type={t} />);
+	return <div className={style_default.MethodSignature}>
+      <span className={style_default.SignatureTitle}>
+        {decl.async && <span className={style_default.TextKeyword}>async </span>}
+        {decl.qualified && <span className={style_default.SignatureQualified}>
+            <span className={style_default.TextIdentifier}>{decl.qualified?.slice(0, -decl.ident.length)}</span>
+          </span>}
+        {decl.kind === "GoDeclFunction" && <span className={style_default.SignatureName}>
+            <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          </span>}
+        <span className={style_default.MethodSignature}>
+          <span className={style_default.SignatureParen}>{"("}</span>
+
+          <span className={style_default.SignatureParams}>
+            <Join$1 items={params}>
+              <span className={style_default.TextOperator}>{", "}</span>
+            </Join$1>
+          </span>
+
+          <span className={style_default.SignatureParen}>{")"} </span>
+          {decl.returnType.length === 1 ? returns : <>
+              <span className={style_default.SignatureParen}>{"("}</span>
+              <Join$1 items={returns}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+              <span className={style_default.SignatureParen}>{")"}</span>
+            </>}
+        </span>
+      </span>
+    </div>;
+}
+function Property$3({ decl, children }) {
+	const Docs = useComponents();
+	const Lang = useLanguageComponents();
+	if (!decl) return null;
+	switch (decl.kind) {
+		case "GoDeclProperty": return children({
+			name: decl.ident,
+			typeName: <Lang.TypeName type={decl.type} />,
+			badges: decl.optional && <Docs.Badge id="optional" />,
+			type: (isField(decl.type) || decl.type.kind in ComplexTypes$2) && <Lang.Type type={decl.type} />
+		});
+		case "GoDeclConst": return children({
+			name: decl.ident,
+			typeName: "const",
+			type: <Lang.Type type={decl.type} />
+		});
+		case "GoDeclReference": return children({ type: <Lang.Type type={decl.type} /> });
+		case "GoDeclType":
+		case "GoDeclTypeAlias": {
+			const typeName$1 = decl.type.kind === "GoTypeStruct" ? "struct" : decl.type.kind === "GoTypeInterface" ? "interface" : decl.kind === "GoDeclTypeAlias" ? "alias" : "type";
+			return children({
+				name: decl.ident,
+				typeName: typeName$1,
+				type: ["GoTypeStruct", "GoTypeInterface"].includes(decl.type.kind) || <Lang.Type type={decl.type} />
+			});
+		}
+	}
+}
+function Declaration$3({ decl }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "GoDeclType": return <>
+          <span className={style_default.TextKeyword}>type </span>
+          <span className={style_default.TextIdentifier}>{decl.ident} </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "GoDeclTypeAlias": return <>
+          <span className={style_default.TextKeyword}>type </span>
+          <span className={style_default.TextIdentifier}>{decl.ident} </span>
+          <span className={style_default.TextOperator}>= </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "GoDeclProperty": return <>
+          <span className={style_default.TypePropertyName}>
+            <span className={style_default.TextIdentifier}>{decl.ident} </span>
+          </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "GoDeclReference": return <Lang.Type type={decl.type} />;
+		case "GoDeclConst": return <>
+          <span className={style_default.TextKeyword}>const </span>
+          <span className={style_default.TextIdentifier}>{decl.ident} </span>
+          <Lang.Type type={decl.type} />
+          <span className={style_default.TextOperator}> = </span>
+          {JSON.stringify(decl.value)}
+        </>;
+	}
+}
+
+//#endregion
+//#region src/languages/python.tsx
+var python_exports = /* @__PURE__ */ __export({
+	Declaration: () => Declaration$2,
+	MethodSignature: () => MethodSignature$2,
+	Property: () => Property$2,
+	Type: () => Type$2,
+	TypeName: () => TypeName$2
+});
+const constStyle$1 = {
+	string: style_default.LiteralString,
+	number: style_default.LiteralNumeric,
+	boolean: style_default.LiteralBoolean
+};
+function showFullType(type) {
+	if (type.kind !== "PythonTypeReference") return false;
+	return type.typeName === "Optional" ? showFullType(type.typeParameters[0]) : type.typeParameters.length > 0;
+}
+function TypeName$2({ type }) {
+	const Lang = useLanguageComponents();
+	if (type.kind === "PythonTypeReference") switch (type.typeName) {
+		case "Optional": return <Lang.TypeName type={type.typeParameters[0]} />;
+		case "List":
+		case "Iterable":
+		case "Literal":
+		case "Union": return type.typeName.toLowerCase();
+	}
+	return <Lang.Type type={type} />;
+}
+function Type$2({ type }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1, SDKReference: SDKReference$1 } = useComponents();
+	switch (type.kind) {
+		case "PythonTypeAny":
+		case "PythonTypeUnknown":
+		case "PythonTypeInt":
+		case "PythonTypeFloat":
+		case "PythonTypeBool": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{type.kind.slice(10).toLowerCase()}</span>
+        </span>;
+		case "PythonTypeString": return <span className={style_default.Type}>
+          <span className={style_default.TypeString}>str</span>
+        </span>;
+		case "PythonTypeLiteral": return <span className={style_default.Type}>
+          <span className={constStyle$1[typeof type.literal.value]}>{JSON.stringify(type.literal.value)}</span>
+        </span>;
+		case "PythonTypeArray": return <span className={style_default.Type}>
+          <span className={style_default.TypeArray}>{"Array<"}</span>
+          <Lang.Type type={type.elementType} />
+          <span className={style_default.TypeArray}>{">"}</span>
+        </span>;
+		case "PythonTypeClass": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>class</span>
+        </span>;
+		case "PythonTypeMap": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>Dict</span>
+        </span>;
+		case "PythonTypeReference": {
+			const params = type.typeParameters?.map((param, key) => <Lang.Type key={key} type={param} />);
+			return <span className={style_default.Type}>
+          <span className={type.typeName === "Optional" ? style_default.TypeArray : ""}>
+            <SDKReference$1 stainlessPath={type.$ref}>{type.typeName}</SDKReference$1>
+          </span>
+          {params && params.length > 0 && <>
+              <span className={style_default.TypeBracket}>{"["}</span>
+              <Join$1 items={params} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+              <span className={style_default.TypeBracket}>{"]"}</span>
+            </>}
+        </span>;
+		}
+	}
+}
+function MethodSignature$2({ decl }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1, Tooltip: Tooltip$1 } = useComponents();
+	const params = decl.parameters.map((param, i) => <React$1.Fragment key={i}>
+      <Tooltip$1 content={<Lang.Type type={param.type} />}>
+        <span className={style_default.TextIdentifier}>{param.ident}</span>
+      </Tooltip$1>
+    </React$1.Fragment>);
+	return <div className={style_default.MethodSignature}>
+      <span className={style_default.SignatureTitle}>
+        {decl.async && <span className={style_default.TextKeyword}>async </span>}
+        {decl.qualified && <span className={style_default.SignatureQualified}>
+            <span className={style_default.TextIdentifier}>{decl.qualified?.slice(0, -decl.ident.length)}</span>
+          </span>}
+        <span className={style_default.SignatureName}>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+        </span>
+        <span className={style_default.MethodSignature}>
+          <span className={style_default.SignatureParen}>{"("}</span>
+
+          <span className={style_default.SignatureParams}>
+            <Join$1 items={params}>
+              <span className={style_default.TextOperator}>{", "}</span>
+            </Join$1>
+          </span>
+
+          <span className={style_default.SignatureParen}>{")"} </span>
+          {decl.returns && <>
+              <span className={style_default.TextOperator}>{" -> "}</span>
+              <Lang.Type type={decl.returns} />
+            </>}
+        </span>
+      </span>
+    </div>;
+}
+function Property$2({ decl, children }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "PythonDeclProperty": return children({
+			name: decl.ident,
+			typeName: <Lang.TypeName type={decl.type} />,
+			type: showFullType(decl.type) && <Lang.Type type={decl.type} />
+		});
+		case "PythonDeclClass": return children({
+			name: decl.ident,
+			typeName: "class"
+		});
+		case "PythonDeclType": return children({
+			name: decl.ident,
+			typeName: "type",
+			type: <Lang.Type type={decl.type} />
+		});
+		case "PythonDeclReference": return children({ type: <Lang.Type type={decl.type} /> });
+	}
+}
+function Declaration$2({ decl }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "PythonDeclProperty": {
+			const nullable = decl.type.kind === "PythonTypeReference" && decl.type.typeName === "Optional" && (decl.type.typeParameters ?? []).length > 0;
+			return <>
+          <span className={style_default.TypePropertyName}>
+            <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          </span>
+          <span className={style_default.TextPunctuation}>: </span>
+          {decl.optional && !nullable ? <>
+              <span className={style_default.TypePlain}>Optional</span>
+              <span className={style_default.TypeBracket}>{"["}</span>
+              <Lang.Type type={decl.type} />
+              <span className={style_default.TypeBrace}>{"]"}</span>
+            </> : <Lang.Type type={decl.type} />}
+        </>;
+		}
+		case "PythonDeclClass": return <>
+          <span className={style_default.TextKeyword}>class </span>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          <span className={style_default.TextPunctuation}>: </span>
+          <span className={`${style_default.TypePreviewContent} ${style_default.TextPunctuation}`}>…</span>
+        </>;
+		case "PythonDeclType": return <>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          <span className={style_default.TextOperator}> = </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "PythonDeclReference": return <Lang.Type type={decl.type} />;
+	}
+}
+
+//#endregion
+//#region src/languages/ruby.tsx
+var ruby_exports = /* @__PURE__ */ __export({
+	Declaration: () => Declaration$1,
+	MethodSignature: () => MethodSignature$1,
+	Property: () => Property$1,
+	Type: () => Type$1,
+	TypeName: () => TypeName$1
+});
+const ComplexTypes$1 = {
+	RubyTypeObject: "object",
+	RubyTypeUnion: "union",
+	RubyTypeIntersection: "intersection",
+	RubyTypeArray: "array",
+	RubyTypeMap: "hash"
+};
+const Keywords = {
+	RubyTypeBinary: "StringIO",
+	RubyTypeUnknown: "untyped",
+	RubyTypeNull: "nil",
+	RubyTypeInteger: "Integer",
+	RubyTypeFloat: "Float",
+	RubyTypeBoolean: "bool"
+};
+function TypeName$1({ type }) {
+	const Lang = useLanguageComponents();
+	return ComplexTypes$1[type.kind] ?? <Lang.Type type={type} />;
+}
+const VALID_IDENTIFIER = /^[_A-Za-z][_A-Za-z0-9]*$/;
+function TypePreview$1({ path }) {
+	const spec = useSpec();
+	const language = useLanguage();
+	const decl = useDeclaration(path, false);
+	const { Join: Join$1 } = useComponents();
+	if (!(decl && "children" in decl && decl.children && decl.children.length > 0) || "type" in decl && decl["type"] && "kind" in decl["type"] && decl["type"]?.["kind"] === "RubyTypeUnion") return;
+	const items = decl.children.map((prop, key) => {
+		const p = spec?.decls?.[language]?.[prop];
+		return <span key={key} className={style_default.TypePropertyName}>
+        <span className={style_default.TextIdentifier}>{p && "ident" in p ? p["ident"] : null}</span>
+      </span>;
+	});
+	return <span className={style_default.TypePreview} data-stldocs-type-preview="properties">
+      <span className={style_default.TypeBrace}>{" {"}</span>
+      <span className={style_default.TypePreviewContent}>
+        {" "}
+        <Join$1 items={items} limit={3}>
+          <span className={style_default.TextOperator}>, </span>
+        </Join$1>{" "}
+      </span>
+      <span className={style_default.TypeBrace}>{"} "}</span>
+    </span>;
+}
+function Type$1({ type }) {
+	const Lang = useLanguageComponents();
+	const { SDKReference: SDKReference$1, Join: Join$1 } = useComponents();
+	switch (type.kind) {
+		case "RubyTypeBinary":
+		case "RubyTypeUnknown":
+		case "RubyTypeNull":
+		case "RubyTypeInteger":
+		case "RubyTypeFloat":
+		case "RubyTypeBoolean": return <span className={style_default.Type}>
+          <span className={style_default.TypeKeyword}>{Keywords[type.kind]}</span>
+        </span>;
+		case "RubyTypeString": return <span className={style_default.Type}>
+          <span className={style_default.TypeString}>String</span>
+        </span>;
+		case "RubyTypeLiteral":
+			switch (typeof type.literal) {
+				case "string": return <span className={style_default.Type}>
+              <span className={style_default.LiteralString}>
+                {":"}
+                {type.literal.match(VALID_IDENTIFIER) ? type.literal : JSON.stringify(type.literal)}
+              </span>
+            </span>;
+				case "number": return <span className={style_default.Type}>
+              <span className={style_default.LiteralNumeric}>{JSON.stringify(type.literal)}</span>
+            </span>;
+				case "boolean": return <span className={style_default.Type}>
+              <span className={style_default.LiteralBoolean}>{JSON.stringify(type.literal)}</span>
+            </span>;
+			}
+			break;
+		case "RubyTypeArray": return <span className={style_default.Type}>
+          <span className={style_default.TypeArray}>{"Array["}</span>
+          <Lang.Type type={type.elementType} />
+          <span className={style_default.TypeArray}>{"]"}</span>
+        </span>;
+		case "RubyTypeMap": return <span className={style_default.Type}>
+          <span className={style_default.TypeArray}>{"Hash["}</span>
+          {type.indexType.kind === "RubyTypeString" ? <span className={style_default.TypeString}>Symbol</span> : <Lang.Type type={type.indexType} />}
+          , <Lang.Type type={type.itemType} />
+          <span className={style_default.TypeArray}>{"]"}</span>
+        </span>;
+		case "RubyTypeReference": {
+			const name = type.ident.split(".").at(-1);
+			if (!type.typeParameters || type.typeParameters.length === 0) return <span className={style_default.Type}>
+            <SDKReference$1 stainlessPath={type.$ref}>{name}</SDKReference$1>
+            <TypePreview$1 path={type.$ref} />
+          </span>;
+			const typeParameters = type.typeParameters.map((t, i) => <Lang.Type key={i} type={t} />);
+			return <span className={style_default.Type}>
+          <SDKReference$1 stainlessPath={type.$ref}>{name}</SDKReference$1>
+          <span className={style_default.TypeBracket}>{"<"}</span>
+          <Join$1 items={typeParameters}>
+            <span className={style_default.TextOperator}>, </span>
+          </Join$1>
+          <span className={style_default.TypeBracket}>{">"}</span>
+          <TypePreview$1 path={type.$ref} />
+        </span>;
+		}
+		case "RubyTypeIntersection":
+		case "RubyTypeUnion": {
+			const items = type.types.map((t, key) => <Lang.Type key={key} type={t} />);
+			const delimiter = type.kind === "RubyTypeUnion" ? "|" : "&";
+			return <span className={style_default.Type}>
+          <span className={style_default.TypePreview} data-stldocs-type-preview="union">
+            <span className={style_default.TypePreviewContent}>
+              <Join$1 items={items} limit={3}>
+                <span className={style_default.TextOperator}> {delimiter} </span>
+              </Join$1>
+            </span>
+          </span>
+        </span>;
+		}
+		case "RubyTypeBuiltinClass": return <span className={style_default.TypeReference}>{type.className}</span>;
+		case "RubyTypeObject": {
+			const items = type.members.map((prop, key) => <span key={key} className={style_default.TextIdentifier}>
+          {prop.ident}
+        </span>);
+			return <span className={style_default.Type}>
+          <span className={style_default.TypePreview} data-stldocs-type-preview="properties">
+            <span className={style_default.TypePreviewContent}>
+              <span className={style_default.TypeBrace}>{"{ "}</span>
+              <Join$1 items={items} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+              <span className={style_default.TypeBrace}>{"}"}</span>
+            </span>
+          </span>
+        </span>;
+		}
+	}
+}
+function MethodSignature$1({ decl }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1 } = useComponents();
+	const params = decl.args.map((param, i) => <React$1.Fragment key={i}>
+      <span className={style_default.TextIdentifier}>{param.ident}</span>
+    </React$1.Fragment>);
+	return <div className={style_default.MethodSignature}>
+      <span className={style_default.SignatureTitle}>
+        <span className={style_default.SignatureQualified}>
+          <span className={style_default.TextIdentifier}>{decl.qualified?.slice(0, -decl.ident.length)}</span>
+        </span>
+        <span className={style_default.SignatureName}>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+        </span>
+        <span className={style_default.MethodSignature}>
+          <span className={style_default.SignatureParen}>{"("}</span>
+
+          <span className={style_default.SignatureParams}>
+            <Join$1 items={params}>
+              <span className={style_default.TextOperator}>{", "}</span>
+            </Join$1>
+          </span>
+
+          <span className={style_default.SignatureParen}>{")"}</span>
+          {" -> "}
+          {decl.returns ? <Lang.Type type={decl.returns} /> : "void"}
+        </span>
+      </span>
+    </div>;
+}
+function Property$1({ decl, children }) {
+	const Lang = useLanguageComponents();
+	switch (decl.kind) {
+		case "RubyDeclProperty": return children({
+			name: decl.ident,
+			typeName: <Lang.TypeName type={decl.type} />,
+			type: decl.type.kind in ComplexTypes$1 && <Lang.Type type={decl.type} />
+		});
+		case "RubyDeclTypeAlias": return children({
+			name: decl.ident,
+			typeName: "alias",
+			type: <Lang.Type type={decl.type} />
+		});
+		case "RubyDeclReference": return children({ type: <Lang.Type type={decl.type} /> });
+		case "RubyDeclClass": return children({
+			name: decl.ident,
+			typeName: "class"
+		});
+	}
+}
+function Declaration$1({ decl }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "RubyDeclProperty": return <>
+          <span className={style_default.TypePropertyName}>
+            <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          </span>
+          <span className={style_default.TextPunctuation}>: </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "RubyDeclTypeAlias": return <>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          <span className={style_default.TextOperator}> = </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "RubyDeclClass": return <>
+          <span className={style_default.TextKeyword}>class </span>
+          <span className={style_default.TextIdentifier}>{decl.ident}</span>
+          <TypePreview$1 path={decl.stainlessPath} />
+        </>;
+		case "RubyDeclReference": return <Lang.Type type={decl.type} />;
+	}
+}
+
+//#endregion
+//#region src/languages/http.tsx
+var http_exports = /* @__PURE__ */ __export({
+	Declaration: () => Declaration,
+	MethodInfo: () => MethodInfo,
+	MethodSignature: () => MethodSignature,
+	Property: () => Property,
+	Type: () => Type,
+	TypeName: () => TypeName
+});
+const ComplexTypes = {
+	HttpTypeUnion: "union",
+	HttpTypeIntersection: "intersection"
+};
+const constStyle = {
+	string: style_default.LiteralString,
+	number: style_default.LiteralNumeric,
+	boolean: style_default.LiteralBoolean
+};
+function Identifier({ name }) {
+	return <>
+      <span className={style_default.TextIdentifier}>
+        {/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(name) ? name : JSON.stringify(name)}
+      </span>
+    </>;
+}
+function TypePreview({ path }) {
+	const spec = useSpec();
+	const language = useLanguage();
+	const decl = useDeclaration(path, false);
+	const { Join: Join$1 } = useComponents();
+	if (!(decl && "children" in decl && decl.children && decl.children.length > 0) || "type" in decl && decl["type"] && "kind" in decl["type"] && decl["type"]["kind"] === "HttpTypeUnion") return;
+	const items = decl.children.map((prop, key) => {
+		const decl$1 = spec?.decls?.[language]?.[prop];
+		return <span key={key} className={style_default.TypePropertyName}>
+        <span className={style_default.TextIdentifier}>{decl$1 && "key" in decl$1 ? decl$1?.["key"] : null}</span>
+      </span>;
+	});
+	return <span className={style_default.TypePreview} data-stldocs-type-preview="properties">
+      <span className={style_default.TypeBrace}>{" { "}</span>
+      <span className={style_default.TypePreviewContent}>
+        <Join$1 items={items} limit={3}>
+          <span className={style_default.TextOperator}>, </span>
+        </Join$1>
+      </span>
+      <span className={style_default.TypeBrace}>{" } "}</span>
+    </span>;
+}
+function TypeName({ type }) {
+	const Lang = useLanguageComponents();
+	if (type.kind === "HttpTypeArray") return <>array of {<Lang.TypeName type={type.elementType} />}</>;
+	if (type.kind === "HttpTypeUnion" && type.types.every((t) => t.kind === "HttpTypeLiteral")) return "enum";
+	if (type.kind === "HttpTypeReference" && type.ident.split(".").at(-1) === "Record") return "map";
+	return ComplexTypes[type.kind] ?? <Lang.Type type={type} />;
+}
+function Type({ type }) {
+	const Lang = useLanguageComponents();
+	const { Join: Join$1, SDKReference: SDKReference$1 } = useComponents();
+	switch (type.kind) {
+		case "HttpTypeUnknown":
+		case "HttpTypeUndefined":
+		case "HttpTypeNull":
+		case "HttpTypeBoolean":
+		case "HttpTypeNumber": return <span className={style_default.Type}>
+          <span className={style_default.TypePlain}>{type.kind.slice(8).toLowerCase()}</span>
+        </span>;
+		case "HttpTypeString": return <span className={style_default.Type}>
+          <span className={style_default.TypePlain}>string</span>
+        </span>;
+		case "HttpTypeLiteral": return <span className={style_default.Type}>
+          <span className={constStyle[typeof type.literal]}>{JSON.stringify(type.literal)}</span>
+        </span>;
+		case "HttpTypeArray": return <span className={style_default.Type}>
+          <span className={style_default.TypeArray}>{"array of "}</span>
+          <Lang.Type type={type.elementType} />
+        </span>;
+		case "HttpTypeIntersection":
+		case "HttpTypeUnion": {
+			const items = type.types.map((t, key) => <Lang.Type key={key} type={t} />);
+			const delimiter = type.kind === "HttpTypeUnion" ? "or" : "and";
+			return <span className={style_default.Type}>
+          <span className={style_default.TypePreview} data-stldocs-type-preview="union">
+            <span className={style_default.TypePreviewContent}>
+              <Join$1 items={items} limit={3}>
+                <span className={style_default.TextOperator}> {delimiter} </span>
+              </Join$1>
+            </span>
+          </span>
+        </span>;
+		}
+		case "HttpTypeReference": {
+			const name = type.ident.split(".").at(-1);
+			const params = type.typeParameters?.map((param, key) => <Lang.Type key={key} type={param} />);
+			if (name === "Record" && type.typeParameters?.length === 2 && type.typeParameters?.at(0).kind === "HttpTypeString") return <>
+            <span className={style_default.TypeArray}>map</span>[{params?.[1]}]
+          </>;
+			return <span className={style_default.Type}>
+          <SDKReference$1 stainlessPath={type.$ref}>{name}</SDKReference$1>
+          {params && params.length > 0 && <>
+              <span className={style_default.TypeBracket}>{"<"}</span>
+              <Join$1 items={params} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>
+              <span className={style_default.TypeBracket}>{">"}</span>
+            </>}
+          <TypePreview path={type.$ref} />
+        </span>;
+		}
+		case "HttpTypeObject": {
+			const items = type.members.map(({ ident }) => <span className={style_default.TypePropertyName} key={ident}>
+          <Identifier name={ident} />
+        </span>);
+			return <span className={style_default.Type}>
+          <span className={style_default.TypePlain}>object</span>
+          <span className={style_default.TypePreview} data-stldocs-type-preview="properties">
+            <span className={style_default.TypeBrace}>{" {"}</span>
+            <span className={style_default.TypePreviewContent}>
+              {" "}
+              <Join$1 items={items} limit={3}>
+                <span className={style_default.TextOperator}>, </span>
+              </Join$1>{" "}
+            </span>
+            <span className={style_default.TypeBrace}>{"} "}</span>
+          </span>
+        </span>;
+		}
+	}
+}
+function MethodSignature({ decl }) {
+	return null;
+}
+function MethodInfo({ decl, children }) {
+	const Docs = useComponents();
+	const params = Object.entries(decl.paramsChildren).filter(([, value]) => value.length).map(([location, value]) => <React.Fragment key={location}>
+        <div className={style_default.MethodParameters} data-stldocs-property-group={location.at(0)}>
+          <h5>
+            {location.at(0).toUpperCase()}
+            {location.slice(1)} Parameters
+            <PropertyToggle target={location.at(0)} />
+          </h5>
+          <Docs.SDKChildren paths={value} />
+        </div>
+      </React.Fragment>);
+	if ((decl.bodyParamsChildren?.["application/json"]?.length ?? 0) > 0) params.push(<div className={style_default.MethodInfoSection}>
+        <h5>
+          Body Parameters
+          <PropertyToggle target="body" />
+        </h5>
+        <div className={style_default.MethodParameters} data-stldocs-property-group="body">
+          <Docs.SDKChildren paths={decl.bodyParamsChildren?.["application/json"] ?? []} />
+        </div>
+      </div>);
+	return <div className={style_default.MethodInfo}>
+      {children && <div className={style_default.MethodContent}>{children}</div>}
+      {params.length > 0 && params}
+      {(decl.responseChildren?.length ?? 0) > 0 && <div className={style_default.MethodInfoSection}>
+          <h5>
+            Returns
+            <PropertyToggle target="returns" />
+          </h5>
+          <div className={style_default.MethodReturns} data-stldocs-property-group="returns">
+            <Docs.SDKChildren paths={decl.responseChildren ?? []} />
+          </div>
+        </div>}
+    </div>;
+}
+function renderVariantInfo(type) {
+	if (type.kind === "HttpTypeUnion" && type.types.every((t) => t.kind === "HttpTypeObject" || t.kind === "HttpTypeReference")) return <>One of the following {type.types.length} object variants:</>;
+}
+function Property({ decl, children }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "HttpDeclProperty": {
+			const variants = renderVariantInfo(decl.type);
+			return children({
+				name: decl.key,
+				typeName: <Lang.TypeName type={decl.type} />,
+				type: decl.type.kind in ComplexTypes && !variants && <Lang.Type type={decl.type} />
+			});
+		}
+		case "HttpDeclTypeAlias": return children({
+			name: decl.ident,
+			typeName: <Lang.TypeName type={decl.type} />
+		});
+		case "HttpDeclReference": return children({ type: <Lang.Type type={decl.type} /> });
+	}
+}
+function Declaration({ decl }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "HttpDeclProperty": return <>
+          <span className={style_default.TypePropertyName}>
+            <Identifier name={decl.key} />
+          </span>
+          <span className={style_default.TextPunctuation}>: </span>
+          {decl.optional && <span className={style_default.TextPunctuation}>optional </span>}
+          <Lang.Type type={decl.type} />
+        </>;
+		case "HttpDeclTypeAlias": return <>
+          <Identifier name={decl.ident} />
+          <span className={style_default.TextOperator}> = </span>
+          <Lang.Type type={decl.type} />
+        </>;
+		case "HttpDeclReference": return <Lang.Type type={decl.type} />;
+	}
+}
+
+//#endregion
+//#region src/languages/index.ts
+var languages_exports = /* @__PURE__ */ __export({
+	go: () => go_exports,
+	http: () => http_exports,
+	java: () => java_exports,
+	kotlin: () => kotlin,
+	node: () => node,
+	python: () => python_exports,
+	ruby: () => ruby_exports,
+	typescript: () => typescript_exports
+});
+const node = typescript_exports;
+const kotlin = java_exports;
+
+//#endregion
+//#region src/contexts/component.tsx
+const defaultContextValue = {
+	components: components_exports,
+	language: languages_exports
+};
+function ComponentProvider({ components, language, children }) {
+	const value = React.useMemo(() => customizeComponents(defaultContextValue, {
+		components,
+		language
+	}), [components, language]);
+	return <ComponentProvider$1 value={value}>{children}</ComponentProvider$1>;
+}
+
+//#endregion
+//#region src/search/printer.tsx
+function Providers({ language, children }) {
+	return <DocsProvider spec={null} language={language}>
+      <ComponentProvider components={{ SDKReference({ stainlessPath, children: children$1 }) {
+		if (!stainlessPath) return children$1;
+		return <span className={style_default.TypeReference}>{children$1}</span>;
+	} }}>
+        {children}
+      </ComponentProvider>
+    </DocsProvider>;
+}
+function RenderType({ type, full }) {
+	const { Type: Type$6, TypeName: TypeName$6 } = useLanguageComponents();
+	return full ? <Type$6 type={type} /> : <TypeName$6 type={type} />;
+}
+function typeName(language, type) {
+	return renderToStaticMarkup(<Providers language={language}>
+      <RenderType type={type} />
+    </Providers>);
+}
+function RenderDeclaration({ decl }) {
+	const { Declaration: Declaration$6 } = useLanguageComponents();
+	return <Declaration$6 decl={decl} />;
+}
+function declaration$1(language, decl) {
+	return renderToStaticMarkup(<Providers language={language}>
+      <RenderDeclaration decl={decl} />
+    </Providers>);
+}
+function RenderMethod({ method }) {
+	const { MethodSignature: MethodSignature$6 } = useLanguageComponents();
+	return <MethodSignature$6 decl={method} />;
+}
+function methodSignature(language, decl) {
+	return renderToStaticMarkup(<Providers language={language}>
+      <RenderMethod method={decl} />
+    </Providers>);
+}
+
+//#endregion
+//#region src/markdown/index.ts
+function declaration(env, decl) {
+	const content = declaration$1(env.language, decl);
+	return paragraph(code(stripMarkup(content)));
+}
+function renderChildren(env, children, nesting = []) {
+	return list(...children.map((child) => renderDecl(env, child, nesting)));
+}
+function renderDecl(env, path, nesting = []) {
+	const decl = getDecl(env, path);
+	const item$1 = item(declaration(env, decl));
+	const hasChildren = "children" in decl && decl.children && decl.children.length > 0;
+	const showModelProps = !("modelPath" in decl && decl["modelPath"]) || env.options.includeModelProperties;
+	if ("docstring" in decl && decl.docstring) item$1.children.push(...parse(decl.docstring));
+	if (hasChildren && showModelProps && !nesting.includes(path)) item$1.push(renderChildren(env, decl.children ?? [], [...nesting, path]));
+	return item$1;
+}
+function renderMethod(env, method) {
+	const decl = getDecl(env, method.stainlessPath);
+	if (!decl) return [paragraph(text("The method "), code(method.name), text(" is not available in this language."))];
+	const signature = methodSignature(env.language, decl);
+	const [httpMethod, endpoint] = method.endpoint.split(" ");
+	const output = [
+		heading(2, method.title),
+		...env.language === "http" ? [] : [paragraph(code(stripMarkup(signature)))],
+		paragraph(strong(text(httpMethod)), text(" "), code(endpoint))
+	];
+	if (method.description) output.push(...parse(method.description));
+	if ("paramsChildren" in decl && Array.isArray(decl.paramsChildren) && decl.paramsChildren.length > 0) output.push(heading(3, "Parameters"), renderChildren(env, decl.paramsChildren));
+	if ("responseChildren" in decl && decl.responseChildren && decl.responseChildren.length > 0) output.push(heading(3, "Returns"), renderChildren(env, decl.responseChildren));
+	const snippet = getSnippet(env, method.stainlessPath);
+	if (snippet) output.push(heading(3, "Example"), fence(env.language, snippet));
+	return output;
+}
+function renderModel(env, model) {
+	return [heading(3, model.title), list(renderDecl(env, `${model.stainlessPath} > (schema)`))];
+}
+function renderResource(env, resource) {
+	const methods = Object.values(resource.methods).filter((method) => getDecl(env, method.stainlessPath)).flatMap((method) => renderMethod(env, method));
+	const models = Object.values(resource.models).filter((model) => getDecl(env, `${model.stainlessPath} > (schema)`)).flatMap((model) => renderModel(env, model));
+	const doc = [heading(1, resource.title), ...methods];
+	if (models.length > 0) doc.push(heading(2, "Domain Types"), ...models);
+	if (!env.options.renderNestedResources) return doc;
+	const children = Object.values(resource.subresources ?? {}).flatMap((resource$1) => renderResource(env, resource$1));
+	return [...doc, ...children];
+}
+function render(env, node$1) {
+	switch (node$1.kind) {
+		case "resource": return renderResource(env, node$1);
+		case "http_method": return renderMethod(env, node$1);
+		case "model": return renderModel(env, node$1);
+	}
+}
+function renderMarkdown(env, node$1) {
+	const content = render(env, node$1);
+	const doc = new Markdoc.Ast.Node("document", {}, content);
+	return Markdoc.format(doc);
+}
+
+//#endregion
+//#region src/search/indexer.ts
+function getResourceNames(resourceIds, topResources) {
+	let element = void 0;
+	let resources = topResources;
+	const resourceName = [];
+	for (const resource of resourceIds) {
+		element = resources?.[resource];
+		if (!element) break;
+		resourceName.push(element.title);
+		resources = element?.subresources;
+	}
+	return resourceName;
+}
+function chunkByLines(content, maxSize = 6e4) {
+	if (Buffer.byteLength(content, "utf8") < maxSize) return [content];
+	const lines = content.split("\n");
+	const chunks = [];
+	let currentChunk = [];
+	let currentSize = 0;
+	for (const line of lines) {
+		const lineSize = Buffer.byteLength(line + "\n", "utf8");
+		if (currentSize + lineSize > maxSize) {
+			chunks.push(currentChunk.join("\n"));
+			currentChunk = [];
+			currentSize = 0;
+		}
+		currentChunk.push(line);
+		currentSize += lineSize;
+	}
+	if (currentChunk.length > 0) chunks.push(currentChunk.join("\n"));
+	return chunks;
+}
+function* generateChatIndex(spec) {
+	for (const [language, readme] of Object.entries(spec.readme)) {
+		const chunks = chunkByLines(readme);
+		for (const chunk of chunks) yield {
+			language,
+			title: "Overview",
+			content: chunk,
+			url: `docs://BASE_PATH/${language}`
+		};
+	}
+	for (const { data } of walkTree(spec)) {
+		if (data.kind !== "http_method") continue;
+		const { title, name, stainlessPath, httpMethod, summary, description } = data;
+		const endpoint = data.endpoint.slice(httpMethod.length).trim();
+		for (const language of Languages) {
+			const decl = spec.decls[language]?.[stainlessPath];
+			if (!decl) continue;
+			const chunks = chunkByLines(renderMarkdown({
+				spec,
+				language,
+				options: { includeModelProperties: true }
+			}, data));
+			for (const chunk of chunks) yield {
+				language,
+				title,
+				name,
+				endpoint,
+				httpMethod,
+				summary,
+				description,
+				stainlessPath,
+				qualified: "qualified" in decl ? decl["qualified"] : void 0,
+				ident: "ident" in decl ? decl["ident"] : void 0,
+				content: chunk,
+				url: generateRoute("docs://BASE_PATH", language, stainlessPath)
+			};
+		}
+	}
+}
+function* generateIndex(spec, renderMarkdownFn, includeTypes) {
+	const parentCrumbs = {};
+	for (const { data } of walkTree(spec, true)) {
+		const { kind, name, title, stainlessPath } = data;
+		const common = {
+			name,
+			title,
+			stainlessPath
+		};
+		const crumbs = getResourceNames(parseStainlessPath(stainlessPath).resource, spec.resources);
+		switch (kind) {
+			case "resource":
+				for (const language of Languages) {
+					if (!data[language]) continue;
+					parentCrumbs[stainlessPath] = crumbs;
+					const { Name, QualifiedName } = data[language];
+					yield {
+						kind,
+						crumbs,
+						language,
+						Name,
+						QualifiedName,
+						priority: 0,
+						...common
+					};
+				}
+				break;
+			case "http_method": {
+				const { summary, endpoint, httpMethod } = data;
+				for (const language of Languages) {
+					const found = spec.decls[language]?.[stainlessPath];
+					if (!found) continue;
+					parentCrumbs[stainlessPath] = [...crumbs, title];
+					const qualified = "qualified" in found ? found["qualified"] : void 0;
+					const ident = qualified?.split(".")?.at(-1);
+					yield {
+						kind,
+						crumbs: [...crumbs, title],
+						ident,
+						qualified,
+						language,
+						description: data.description ? renderMarkdownFn?.(data.description) ?? data.description : void 0,
+						endpoint: endpoint.slice(httpMethod.length).trim(),
+						httpMethod,
+						summary,
+						priority: 0,
+						...common
+					};
+				}
+				break;
+			}
+			case "model": for (const language of Languages) {
+				if (!spec.decls[language]) continue;
+				parentCrumbs[stainlessPath] = [...crumbs, title];
+				const schema = spec.decls[language]?.[`${stainlessPath} > (schema)`];
+				const children = (schema && "children" in schema ? schema?.["children"] : void 0)?.map((childPath) => {
+					const child = spec.decls?.[language]?.[childPath];
+					return child?.["ident"] ?? child?.["name"] ?? child?.["key"] ?? child?.["type"]?.["literal"]?.["value"] ?? child?.["type"]?.["literal"] ?? child?.["type"]?.["value"];
+				})?.filter((child) => child) ?? [];
+				yield {
+					kind,
+					crumbs: [...crumbs, title],
+					children,
+					language,
+					priority: 2,
+					ident: schema && "ident" in schema ? schema?.["ident"] : void 0,
+					...common
+				};
+			}
+		}
+	}
+	for (const language of Languages) {
+		const decls = spec.decls?.[language];
+		if (!decls) continue;
+		for (const decl of Object.values(decls)) switch (decl.kind) {
+			case "JavaDeclProperty":
+			case "GoDeclProperty":
+			case "PythonDeclProperty":
+			case "RubyDeclProperty":
+			case "HttpDeclProperty":
+			case "TSDeclProperty":
+				{
+					const parsedPath = parseStainlessPath(decl.stainlessPath);
+					const type = includeTypes === false ? void 0 : typeName(language, decl.type);
+					const name = decl["ident"] ?? decl["name"] ?? decl["key"];
+					const parent = parentCrumbs[parsedPath.routable];
+					if (parent === void 0) continue;
+					const matches = decl.stainlessPath.matchAll(/\((property|params|param)\) ([^\s]+)/g);
+					const props = Array.from(matches).map((p) => p[2]).filter((p) => p !== void 0);
+					yield {
+						kind: "property",
+						name,
+						stainlessPath: decl.stainlessPath,
+						crumbs: [...parent, ...props],
+						docstring: decl.docstring ? renderMarkdownFn?.(decl.docstring) ?? decl.docstring : void 0,
+						type,
+						language,
+						priority: 3
+					};
+				}
+				break;
+		}
+	}
+}
+
+//#endregion
+//#region src/search/providers/algolia.ts
+async function buildIndex(appId, indexName, writeKey, spec, renderMarkdown$1) {
+	if (!appId || !indexName || !writeKey) return;
+	const objects = Array.from(generateIndex(spec, renderMarkdown$1));
+	const client = searchClient(appId, writeKey);
+	await client.setSettings({
+		indexName,
+		indexSettings: {
+			highlightPreTag: "<mark>",
+			highlightPostTag: "</mark>",
+			customRanking: ["asc(priority)"],
+			attributesForFaceting: ["language", "kind"],
+			searchableAttributes: [...SearchableAttributes]
+		}
+	});
+	await client.replaceAllObjects({
+		indexName,
+		objects
+	});
+}
+async function buildChatIndex(appId, indexName, writeKey, spec) {
+	if (!appId || !indexName || !writeKey) return;
+	const objects = Array.from(generateChatIndex(spec));
+	const client = searchClient(appId, writeKey);
+	await client.setSettings({
+		indexName,
+		indexSettings: {
+			attributesForFaceting: ["language"],
+			attributeForDistinct: "stainlessPath",
+			searchableAttributes: SearchableAttributesChat
+		}
+	});
+	await client.replaceAllObjects({
+		indexName,
+		objects
+	});
+}
+async function search({ settings: { appId, indexName, searchKey }, params: { query, language, kind } }) {
+	const client = searchClient(appId, searchKey);
+	const filters = language ? `language:${language}` : void 0;
+	const facetFilters = kind ? [`kind:${kind}`] : void 0;
+	const { results } = await client.search({ requests: [{
+		query,
+		indexName,
+		filters,
+		hitsPerPage: 5,
+		facets: ["kind"]
+	}, {
+		query,
+		indexName,
+		filters,
+		facetFilters,
+		facets: ["kind"],
+		hitsPerPage: 50
+	}] });
+	if ("hits" in results[0] && "hits" in results[1]) {
+		const [{ nbHits, facets }, { hits }] = results;
+		return {
+			hits,
+			nbHits: nbHits ?? 0,
+			facets
+		};
+	}
+}
+
+//#endregion
+//#region src/contexts/search.tsx
+const [Provider, useSearchContext] = createStrictContext("SearchContext");
+function useSearch() {
+	const { settings } = useSearchContext();
+	return (params) => search({
+		settings,
+		params
+	});
+}
+function SearchProvider({ children,...props }) {
+	return <Provider value={props}>{children}</Provider>;
+}
+
+//#endregion
+//#region src/contexts/index.tsx
+var contexts_exports = /* @__PURE__ */ __export({
+	ComponentProvider: () => ComponentProvider$1,
+	DocsProvider: () => DocsProvider,
+	MarkdownContext: () => MarkdownContext,
+	MarkdownProvider: () => MarkdownProvider,
+	NavigationProvider: () => NavigationProvider,
+	SearchProvider: () => SearchProvider,
+	customizeComponents: () => customizeComponents,
+	useComponentContext: () => useComponentContext,
+	useComponents: () => useComponents$1,
+	useContentPanelLayout: () => useContentPanelLayout,
+	useDeclaration: () => useDeclaration,
+	useDocs: () => useDocs,
+	useHighlight: () => useHighlight,
+	useLanguage: () => useLanguage,
+	useLanguageComponents: () => useLanguageComponents,
+	useMarkdownContext: () => useMarkdownContext,
+	useNavigation: () => useNavigation,
+	useRenderMarkdown: () => useRenderMarkdown,
+	useResource: () => useResource,
+	useSearch: () => useSearch,
+	useSearchContext: () => useSearchContext,
+	useSettings: () => useSettings,
+	useSnippet: () => useSnippet,
+	useSpec: () => useSpec
+});
+function useLanguageComponents() {
+	const language = useLanguage();
+	const definition = useComponentContext().language[language];
+	if (!definition) throw new Error(`Language component definition not found for language: ${language}`);
+	return definition;
+}
+
+//#endregion
+export { TypeName$5 as $, PropertyDescription as $t, ruby_exports as A, SDKRequestTitle as At, Type$3 as B, Markdown as Bt, TypeName as C, SDKIcon as Ct, Property$1 as D, SDKMethodInfo as Dt, MethodSignature$1 as E, SDKMethodHeader as Et, TypeName$2 as F, Expander as Ft, Property$4 as G, HttpMethods as Gt, go_exports as H, Tooltip as Ht, python_exports as I, Input as It, java_exports as J, MethodHeader as Jt, Type$4 as K, Method as Kt, Declaration$3 as L, Join as Lt, MethodSignature$2 as M, usePropertyModel as Mt, Property$2 as N, useReferenceNesting as Nt, Type$1 as O, SDKModel as Ot, Type$2 as P, Badge as Pt, Type$5 as Q, Property$6 as Qt, MethodSignature$3 as R, Link as Rt, Type as S, SDKExample as St, Declaration$1 as T, SDKMethod as Tt, Declaration$4 as U, VirtualExpander as Ut, TypeName$3 as V, ToggleButton as Vt, MethodSignature$4 as W, HttpMethodIcons as Wt, MethodSignature$5 as X, MethodInfo$1 as Xt, Declaration$5 as Y, MethodIconBadge as Yt, Property$5 as Z, MethodRoute as Zt, node as _, PropertyModelContext as _t, useSearchContext as a, SidebarResource as at, MethodSignature as b, SDKConstraints as bt, search as c, SDKOverview as ct, render as d, SDKRoot as dt, PropertyToggle as en, typescript_exports as et, renderMarkdown as f, Snippet as ft, languages_exports as g, SnippetResponse as gt, kotlin as h, SnippetRequestContainer as ht, useSearch as i, SidebarMethod as it, Declaration$2 as j, SDKSnippetLanguages as jt, TypeName$1 as k, SDKReference as kt, generateIndex as l, SDKResource as lt, defaultContextValue as m, SnippetContainer as mt, useLanguageComponents as n, Sidebar as nt, buildChatIndex as o, SDKBreadcrumbs as ot, ComponentProvider as p, SnippetCode as pt, TypeName$4 as q, MethodDescription as qt, SearchProvider as r, SidebarExpander as rt, buildIndex as s, SDKMethodSummary as st, contexts_exports as t, components_exports as tt, declaration as u, SDKResourceHeader as ut, Declaration as v, ReferenceNestingContext as vt, http_exports as w, SDKLanguageBlock as wt, Property as x, SDKDeclaration as xt, MethodInfo as y, SDKChildren as yt, Property$3 as z, ListView as zt };