@stainless-api/docs-ui 0.1.0-beta.6 → 0.1.0-beta.61

package/dist/languages-BO5YJ6cy.js

@@ -0,0 +1,28 @@
+import { t as __exportAll } from "./chunk-BN_g-Awi.js";
+import { o as typescript_exports } from "./typescript-D924WidI.js";
+import { o as java_exports } from "./java-DSyzO-6F.js";
+import { o as go_exports } from "./go-DuKdRGqU.js";
+import { o as python_exports } from "./python-D8ABqtn1.js";
+import { o as ruby_exports } from "./ruby-261jvCjl.js";
+import { s as http_exports } from "./http-C7bu4oCl.js";
+import { o as csharp_exports } from "./csharp-Dl2RIiYP.js";
+import { o as cli_exports } from "./cli-0bJ66S1r.js";
+
+//#region src/languages/index.ts
+var languages_exports = /* @__PURE__ */ __exportAll({
+	cli: () => cli_exports,
+	csharp: () => csharp_exports,
+	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
+export { languages_exports as n, node as r, kotlin as t };

package/dist/markdown/index.d.ts

@@ -0,0 +1,12 @@
+import { f as Resource, l as Method, r as DeclarationNode, u as Model } from "../index-zNpvNvtN.js";
+import "../sdk-CIxaNoAs.js";
+import { EnvironmentType } from "./utils.js";
+import { t as printer_d_exports } from "./printer.js";
+import { Node } from "@markdoc/markdoc";
+
+//#region src/markdown/index.d.ts
+declare function declaration(env: EnvironmentType, decl: DeclarationNode): Node;
+declare function render(env: EnvironmentType, node: Resource | Method | Model): Node[];
+declare function renderMarkdown(env: EnvironmentType, node: Resource | Method | Model): string;
+//#endregion
+export { declaration, printer_d_exports as printer, render, renderMarkdown };

package/dist/markdown/index.js

@@ -0,0 +1,105 @@
+import "../docs-Di94viZV.js";
+import "../component-generics-POFirVVb.js";
+import "../navigation-aoYZ_tl4.js";
+import "../markdown-D2JWyRws.js";
+import "../contexts-CeV_L_Iy.js";
+import "../use-components-BUz3GbO4.js";
+import "../properties-DGL2J11L.js";
+import "../method-jTnA0G8m.js";
+import "../primitives-DQLc9kN7.js";
+import "../icons-BYKn5X8E.js";
+import "../sdk-GGpyGTao.js";
+import "../snippets-kI8eNs1F.js";
+import "../overview-BnagZfH1.js";
+import "../breadcrumbs-CqA6kow2.js";
+import "../sidebar-BWno0E4w.js";
+import "../components-FEHnQBJC.js";
+import "../typescript-D924WidI.js";
+import "../java-DSyzO-6F.js";
+import "../go-DuKdRGqU.js";
+import "../python-D8ABqtn1.js";
+import "../ruby-261jvCjl.js";
+import "../http-C7bu4oCl.js";
+import "../csharp-Dl2RIiYP.js";
+import "../cli-0bJ66S1r.js";
+import "../languages-BO5YJ6cy.js";
+import "../component-CjJJYIxG.js";
+import { code, fence, heading, item, list, paragraph, parse, strong, text } from "./md.js";
+import { getDecl, getSnippet, stripMarkup } from "./utils.js";
+import { declaration as declaration$1, methodSignature, t as printer_exports } from "./printer.js";
+import Markdoc from "@markdoc/markdoc";
+
+//#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 (env.language === "http") {
+		const p = "paramsChildren" in decl && typeof decl.paramsChildren === "object" ? decl.paramsChildren : {};
+		for (const [location, value] of Object.entries(p)) {
+			if (value.length < 1) continue;
+			output.push(heading(3, [
+				text(location.at(0)?.toUpperCase() ?? ""),
+				text(location.slice(1)),
+				text(" Parameters")
+			]), renderChildren(env, value));
+		}
+		const bp = "bodyParamsChildren" in decl ? decl.bodyParamsChildren?.["application/json"] : [];
+		if (bp && bp.length > 0) output.push(heading(3, "Body Parameters"), renderChildren(env, bp));
+	}
+	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) => renderResource(env, resource));
+	return [...doc, ...children];
+}
+function render(env, node) {
+	switch (node.kind) {
+		case "resource": return renderResource(env, node);
+		case "http_method": return renderMethod(env, node);
+		case "model": return renderModel(env, node);
+	}
+}
+function renderMarkdown(env, node) {
+	const content = render(env, node);
+	const doc = new Markdoc.Ast.Node("document", {}, content);
+	return Markdoc.format(doc);
+}
+
+//#endregion
+export { declaration, printer_exports as printer, render, renderMarkdown };

package/dist/markdown/md.d.ts

@@ -0,0 +1,15 @@
+import { Node } from "@markdoc/markdoc";
+
+//#region src/markdown/md.d.ts
+declare function heading(level: number, children: string | Node[]): Node;
+declare function text(content: string): Node;
+declare function code(content: string): Node;
+declare function paragraph(...children: Node[]): Node;
+declare function list(...children: Node[]): Node;
+declare function item(...children: Node[]): Node;
+declare function strong(...children: Node[]): Node;
+declare function inline(...children: Node[]): Node;
+declare function fence(language: string, content: string): Node;
+declare function parse(content: string): Node[];
+//#endregion
+export { code, fence, heading, inline, item, list, paragraph, parse, strong, text };

package/dist/markdown/md.js

@@ -0,0 +1,41 @@
+import Markdoc from "@markdoc/markdoc";
+
+//#region src/markdown/md.ts
+function heading(level, children) {
+	const content = inline(...typeof children === "string" ? [text(children)] : children);
+	return new Markdoc.Ast.Node("heading", { level }, [content]);
+}
+function text(content) {
+	return new Markdoc.Ast.Node("text", { content });
+}
+function code(content) {
+	return new Markdoc.Ast.Node("code", { content });
+}
+function paragraph(...children) {
+	const inline = new Markdoc.Ast.Node("inline", {}, children);
+	return new Markdoc.Ast.Node("paragraph", {}, [inline]);
+}
+function list(...children) {
+	return new Markdoc.Ast.Node("list", { ordered: false }, children);
+}
+function item(...children) {
+	return new Markdoc.Ast.Node("item", {}, children);
+}
+function strong(...children) {
+	return new Markdoc.Ast.Node("strong", {}, children);
+}
+function inline(...children) {
+	return new Markdoc.Ast.Node("inline", {}, children);
+}
+function fence(language, content) {
+	return new Markdoc.Ast.Node("fence", {
+		language,
+		content
+	});
+}
+function parse(content) {
+	return Markdoc.parse(content).children;
+}
+
+//#endregion
+export { code, fence, heading, inline, item, list, paragraph, parse, strong, text };

package/dist/markdown/printer.d.ts

@@ -0,0 +1,13 @@
+import { r as DeclarationNode, v as Type } from "../index-zNpvNvtN.js";
+import { t as DocsLanguage } from "../routing-CtbZJru_.js";
+
+//#region src/markdown/printer.d.ts
+declare namespace printer_d_exports {
+  export { declaration, methodSignature, type, typeName };
+}
+declare function typeName(language: DocsLanguage, type: Type): string;
+declare function type(language: DocsLanguage, type: Type): string;
+declare function declaration(language: DocsLanguage, decl: DeclarationNode): string;
+declare function methodSignature(language: DocsLanguage, decl: DeclarationNode): string;
+//#endregion
+export { declaration, methodSignature, printer_d_exports as t, type, typeName };

package/dist/markdown/printer.js

@@ -0,0 +1,98 @@
+import { t as __exportAll } from "../chunk-BN_g-Awi.js";
+import { t as DocsProvider } from "../docs-Di94viZV.js";
+import "../component-generics-POFirVVb.js";
+import "../navigation-aoYZ_tl4.js";
+import "../markdown-D2JWyRws.js";
+import { n as useLanguageComponents } from "../contexts-CeV_L_Iy.js";
+import "../use-components-BUz3GbO4.js";
+import { t as style_default } from "../style-LwfvXElj.js";
+import "../properties-DGL2J11L.js";
+import "../method-jTnA0G8m.js";
+import "../primitives-DQLc9kN7.js";
+import "../icons-BYKn5X8E.js";
+import "../sdk-GGpyGTao.js";
+import "../snippets-kI8eNs1F.js";
+import "../overview-BnagZfH1.js";
+import "../breadcrumbs-CqA6kow2.js";
+import "../sidebar-BWno0E4w.js";
+import "../components-FEHnQBJC.js";
+import "../typescript-D924WidI.js";
+import "../java-DSyzO-6F.js";
+import "../go-DuKdRGqU.js";
+import "../python-D8ABqtn1.js";
+import "../ruby-261jvCjl.js";
+import "../http-C7bu4oCl.js";
+import "../csharp-Dl2RIiYP.js";
+import "../cli-0bJ66S1r.js";
+import "../languages-BO5YJ6cy.js";
+import { t as ComponentProvider } from "../component-CjJJYIxG.js";
+import "react";
+import { jsx } from "react/jsx-runtime";
+import { renderToStaticMarkup } from "react-dom/server";
+
+//#region src/markdown/printer.tsx
+var printer_exports = /* @__PURE__ */ __exportAll({
+	declaration: () => declaration,
+	methodSignature: () => methodSignature,
+	type: () => type,
+	typeName: () => typeName
+});
+function SDKReference({ stainlessPath, children }) {
+	if (!stainlessPath) return children;
+	return /* @__PURE__ */ jsx("span", {
+		className: style_default.TypeReference,
+		children
+	});
+}
+function Providers({ language, children }) {
+	return /* @__PURE__ */ jsx(DocsProvider, {
+		spec: null,
+		language,
+		children: /* @__PURE__ */ jsx(ComponentProvider, {
+			components: { SDKReference },
+			children
+		})
+	});
+}
+function RenderType({ type, full }) {
+	const { Type, TypeName } = useLanguageComponents();
+	return full ? /* @__PURE__ */ jsx(Type, { type }) : /* @__PURE__ */ jsx(TypeName, { type });
+}
+function typeName(language, type) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderType, { type })
+	}));
+}
+function type(language, type) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderType, {
+			type,
+			full: true
+		})
+	}));
+}
+function RenderDeclaration({ decl }) {
+	const { Declaration } = useLanguageComponents();
+	return /* @__PURE__ */ jsx(Declaration, { decl });
+}
+function declaration(language, decl) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderDeclaration, { decl })
+	}));
+}
+function RenderMethod({ method }) {
+	const { MethodSignature } = useLanguageComponents();
+	return /* @__PURE__ */ jsx(MethodSignature, { decl: method });
+}
+function methodSignature(language, decl) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderMethod, { method: decl })
+	}));
+}
+
+//#endregion
+export { declaration, methodSignature, printer_exports as t, type, typeName };

package/dist/markdown/utils.d.ts

@@ -0,0 +1,21 @@
+import { c as LanguageDeclNodes, g as SpecLanguage, h as Spec } from "../index-zNpvNvtN.js";
+import { t as DocsLanguage } from "../routing-CtbZJru_.js";
+import { C as TransformRequestSnippetFn } from "../sdk-CIxaNoAs.js";
+
+//#region src/markdown/utils.d.ts
+type EnvironmentType = {
+  spec: Spec;
+  language: DocsLanguage;
+  transforms?: {
+    transformRequestSnippet?: TransformRequestSnippetFn;
+  };
+  options: {
+    renderNestedResources?: boolean;
+    includeModelProperties?: boolean;
+  };
+};
+declare function getDecl(env: EnvironmentType, path: string): LanguageDeclNodes[SpecLanguage] | undefined;
+declare function getSnippet(env: EnvironmentType, path: string): string | undefined;
+declare function stripMarkup(content: string): string;
+//#endregion
+export { EnvironmentType, getDecl, getSnippet, stripMarkup };

package/dist/markdown/utils.js

@@ -0,0 +1,31 @@
+import { Parser } from "htmlparser2";
+
+//#region src/markdown/utils.ts
+function getDecl(env, path) {
+	const decl = env.spec?.decls?.[env.language]?.[path];
+	if (decl?.kind?.endsWith("Reference")) {
+		const refId = "type" in decl && typeof decl["type"] === "object" && "$ref" in decl["type"] ? decl["type"]["$ref"] : null;
+		if (refId === path) return decl;
+		if (refId) return getDecl(env, refId);
+	}
+	return decl;
+}
+function getSnippet(env, path) {
+	const lang = env.language === "http" ? "http.curl" : `${env.language}.default`;
+	let snippet = env.spec?.snippets?.[lang]?.[path];
+	if (typeof snippet === "string" && env.transforms?.transformRequestSnippet) snippet = env.transforms.transformRequestSnippet({
+		snippet,
+		language: env.language
+	});
+	return snippet;
+}
+function stripMarkup(content) {
+	let output = "";
+	new Parser({ ontext(content) {
+		output += content;
+	} }).parseComplete(content);
+	return output;
+}
+
+//#endregion
+export { getDecl, getSnippet, stripMarkup };

package/dist/markdown-B517MrZh.d.ts

@@ -0,0 +1,22 @@
+import * as React$1 from "react";
+import * as react_jsx_runtime39 from "react/jsx-runtime";
+
+//#region src/contexts/markdown.d.ts
+type MarkdownContext = {
+  highlight: (content: string, language: string) => string | Promise<string>;
+  render: (content: string) => string | Promise<string>;
+};
+declare const MarkdownContext: React$1.Context<MarkdownContext>;
+declare const useMarkdownContext: () => MarkdownContext;
+declare function useRenderMarkdown(content?: string): string | undefined;
+declare function useHighlight(content: string, language?: string): string;
+type MarkdownProviderProps = MarkdownContext & {
+  children: React$1.ReactNode;
+};
+declare function MarkdownProvider({
+  render,
+  highlight,
+  children
+}: MarkdownProviderProps): react_jsx_runtime39.JSX.Element;
+//#endregion
+export { useMarkdownContext as a, useHighlight as i, MarkdownProvider as n, useRenderMarkdown as o, MarkdownProviderProps as r, MarkdownContext as t };

package/dist/markdown-C7Tb41LZ.d.ts

@@ -0,0 +1,22 @@
+import * as React$1 from "react";
+import * as react_jsx_runtime41 from "react/jsx-runtime";
+
+//#region src/contexts/markdown.d.ts
+type MarkdownContext = {
+  highlight: (content: string, language: string) => string | Promise<string>;
+  render: (content: string) => string | Promise<string>;
+};
+declare const MarkdownContext: React$1.Context<MarkdownContext>;
+declare const useMarkdownContext: () => MarkdownContext;
+declare function useRenderMarkdown(content?: string): string | undefined;
+declare function useHighlight(content: string, language?: string): string;
+type MarkdownProviderProps = MarkdownContext & {
+  children: React$1.ReactNode;
+};
+declare function MarkdownProvider({
+  render,
+  highlight,
+  children
+}: MarkdownProviderProps): react_jsx_runtime41.JSX.Element;
+//#endregion
+export { useMarkdownContext as a, useHighlight as i, MarkdownProvider as n, useRenderMarkdown as o, MarkdownProviderProps as r, MarkdownContext as t };

package/dist/markdown-D2JWyRws.js

@@ -0,0 +1,49 @@
+import { a as useLanguage } from "./docs-Di94viZV.js";
+import * as React$1 from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/contexts/markdown.tsx
+const HighlightLanguageMappings = {
+	node: "typescript",
+	http: "bash",
+	cli: "bash"
+};
+const MarkdownContext = React$1.createContext({
+	highlight: (content) => content,
+	render: (content) => content
+});
+const useMarkdownContext = () => React$1.useContext(MarkdownContext);
+function useRenderMarkdown(content) {
+	const { render } = React$1.useContext(MarkdownContext);
+	return React$1.useMemo(() => {
+		if (!content) return void 0;
+		const rendered = render(content);
+		return typeof rendered === "string" ? rendered : React$1.use(rendered);
+	}, [content, render]);
+}
+function useHighlight(content, language) {
+	const { highlight } = React$1.useContext(MarkdownContext);
+	const defaultLanguage = useLanguage();
+	const lang = language ?? defaultLanguage;
+	return React$1.useMemo(() => {
+		if (lang === "none") return content;
+		const rendered = highlight(content, HighlightLanguageMappings[lang] ?? lang);
+		return typeof rendered === "string" ? rendered : React$1.use(rendered);
+	}, [
+		content,
+		highlight,
+		lang
+	]);
+}
+function MarkdownProvider({ render, highlight, children }) {
+	return /* @__PURE__ */ jsx(MarkdownContext.Provider, {
+		value: {
+			render,
+			highlight
+		},
+		children
+	});
+}
+
+//#endregion
+export { useRenderMarkdown as a, useMarkdownContext as i, MarkdownProvider as n, useHighlight as r, MarkdownContext as t };

package/dist/method-BaQEZVlw.d.ts

@@ -0,0 +1,59 @@
+import * as React$1 from "react";
+import { ReactNode } from "react";
+import * as react_jsx_runtime10 from "react/jsx-runtime";
+
+//#region src/components/method.d.ts
+type MethodHeaderProps = {
+  title: ReactNode;
+  level?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5';
+  signature?: ReactNode;
+  badges?: ReactNode;
+  children?: ReactNode;
+};
+declare function MethodHeader({
+  title,
+  badges,
+  signature,
+  children,
+  level
+}: MethodHeaderProps): react_jsx_runtime10.JSX.Element;
+type MethodRouteProps = {
+  httpMethod?: string;
+  endpoint?: string | ReactNode;
+  iconOnly?: boolean;
+};
+declare function MethodRoute({
+  httpMethod,
+  endpoint,
+  iconOnly
+}: MethodRouteProps): react_jsx_runtime10.JSX.Element;
+type MethodDescriptionProps = {
+  description?: string;
+};
+declare function MethodDescription({
+  description
+}: MethodDescriptionProps): react_jsx_runtime10.JSX.Element | undefined;
+type MethodInfoProps = {
+  children?: ReactNode;
+  parameters?: ReactNode;
+  returns?: ReactNode;
+};
+declare function MethodInfo({
+  children,
+  parameters,
+  returns
+}: MethodInfoProps): react_jsx_runtime10.JSX.Element;
+type MethodProps = {
+  id?: string;
+  header?: ReactNode;
+  children?: ReactNode;
+} & React$1.HTMLProps<HTMLDivElement>;
+declare function Method({
+  id,
+  header,
+  children,
+  className,
+  ...props
+}: MethodProps): react_jsx_runtime10.JSX.Element;
+//#endregion
+export { MethodHeaderProps as a, MethodProps as c, MethodHeader as i, MethodRoute as l, MethodDescription as n, MethodInfo as o, MethodDescriptionProps as r, MethodInfoProps as s, Method as t, MethodRouteProps as u };

package/dist/method-Dln4ZTIB.d.ts

@@ -0,0 +1,59 @@
+import * as React$1 from "react";
+import { ReactNode } from "react";
+import * as react_jsx_runtime16 from "react/jsx-runtime";
+
+//#region src/components/method.d.ts
+type MethodHeaderProps = {
+  title: ReactNode;
+  level?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5';
+  signature?: ReactNode;
+  badges?: ReactNode;
+  children?: ReactNode;
+};
+declare function MethodHeader({
+  title,
+  badges,
+  signature,
+  children,
+  level
+}: MethodHeaderProps): react_jsx_runtime16.JSX.Element;
+type MethodRouteProps = {
+  httpMethod?: string;
+  endpoint?: string | ReactNode;
+  iconOnly?: boolean;
+};
+declare function MethodRoute({
+  httpMethod,
+  endpoint,
+  iconOnly
+}: MethodRouteProps): react_jsx_runtime16.JSX.Element;
+type MethodDescriptionProps = {
+  description?: string;
+};
+declare function MethodDescription({
+  description
+}: MethodDescriptionProps): react_jsx_runtime16.JSX.Element | undefined;
+type MethodInfoProps = {
+  children?: ReactNode;
+  parameters?: ReactNode;
+  returns?: ReactNode;
+};
+declare function MethodInfo({
+  children,
+  parameters,
+  returns
+}: MethodInfoProps): react_jsx_runtime16.JSX.Element;
+type MethodProps = {
+  id?: string;
+  header?: ReactNode;
+  children?: ReactNode;
+} & React$1.HTMLProps<HTMLDivElement>;
+declare function Method({
+  id,
+  header,
+  children,
+  className,
+  ...props
+}: MethodProps): react_jsx_runtime16.JSX.Element;
+//#endregion
+export { MethodHeaderProps as a, MethodProps as c, MethodHeader as i, MethodRoute as l, MethodDescription as n, MethodInfo as o, MethodDescriptionProps as r, MethodInfoProps as s, Method as t, MethodRouteProps as u };

package/dist/method-jTnA0G8m.js

@@ -0,0 +1,90 @@
+import { t as useComponents } from "./use-components-BUz3GbO4.js";
+import { t as style_default } from "./style-LwfvXElj.js";
+import { i as PropertyToggle } from "./properties-DGL2J11L.js";
+import "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import clsx from "clsx";
+import { Badge, getHttpMethod } from "@stainless-api/ui-primitives";
+
+//#region src/components/method.tsx
+function MethodHeader({ title, badges, signature, children, level }) {
+	const Heading = level ?? "h5";
+	return /* @__PURE__ */ jsxs("div", {
+		className: style_default.MethodHeader,
+		children: [
+			/* @__PURE__ */ jsx(Heading, {
+				className: style_default.MethodTitle,
+				children: title
+			}),
+			badges && /* @__PURE__ */ jsx("div", {
+				className: style_default.MethodBadges,
+				children: badges
+			}),
+			signature,
+			children
+		]
+	});
+}
+function MethodRoute({ httpMethod, endpoint, iconOnly }) {
+	const httpMethodTyped = getHttpMethod(httpMethod);
+	return /* @__PURE__ */ jsxs("div", {
+		className: style_default.MethodRoute,
+		children: [httpMethodTyped && /* @__PURE__ */ jsx(Badge.HTTP, {
+			method: httpMethodTyped,
+			iconOnly,
+			size: "sm"
+		}), endpoint && /* @__PURE__ */ jsx("span", {
+			className: style_default.MethodRouteEndpoint,
+			children: endpoint
+		})]
+	});
+}
+function MethodDescription({ description }) {
+	const { Markdown } = useComponents();
+	if (description) return /* @__PURE__ */ jsx("div", {
+		className: style_default.MethodDescription,
+		children: /* @__PURE__ */ jsx(Markdown, { content: description })
+	});
+}
+function MethodInfo({ children, parameters, returns }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: style_default.MethodInfo,
+		children: [
+			children && /* @__PURE__ */ jsx("div", {
+				className: style_default.MethodContent,
+				children
+			}),
+			parameters && /* @__PURE__ */ jsxs("div", {
+				className: style_default.MethodInfoSection,
+				children: [/* @__PURE__ */ jsxs("h5", { children: ["Parameters", /* @__PURE__ */ jsx(PropertyToggle, { target: "parameters" })] }), /* @__PURE__ */ jsx("div", {
+					className: style_default.MethodParameters,
+					"data-stldocs-property-group": "parameters",
+					children: parameters
+				})]
+			}),
+			returns && /* @__PURE__ */ jsxs("div", {
+				className: style_default.MethodInfoSection,
+				children: [/* @__PURE__ */ jsxs("h5", { children: ["Returns", /* @__PURE__ */ jsx(PropertyToggle, { target: "returns" })] }), /* @__PURE__ */ jsx("div", {
+					className: style_default.MethodReturns,
+					"data-stldocs-property-group": "returns",
+					children: returns
+				})]
+			})
+		]
+	});
+}
+function Method({ id, header, children, className, ...props }) {
+	return /* @__PURE__ */ jsxs("div", {
+		id,
+		className: clsx(style_default.Method, className),
+		tabIndex: 0,
+		...props,
+		children: [header, /* @__PURE__ */ jsx("div", {
+			className: style_default.MethodBody,
+			children
+		})]
+	});
+}
+
+//#endregion
+export { MethodRoute as a, MethodInfo as i, MethodDescription as n, MethodHeader as r, Method as t };