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

package/dist/snippets-kI8eNs1F.js

@@ -0,0 +1,164 @@
+import { a as useLanguage, c as useSnippet, r as useDeclaration } from "./docs-Di94viZV.js";
+import { r as useHighlight } from "./markdown-D2JWyRws.js";
+import { t as useComponents } from "./use-components-BUz3GbO4.js";
+import { t as style_default } from "./style-LwfvXElj.js";
+import * as React$1 from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import clsx from "clsx";
+import { CheckIcon, CircleAlertIcon, CopyIcon } from "lucide-react";
+import { Badge, Button, getHttpMethod } from "@stainless-api/ui-primitives";
+
+//#region src/components/snippets.tsx
+function SnippetCode({ content, language }) {
+	const lang = useLanguage();
+	const highlighted = useHighlight(content, language || lang);
+	return /* @__PURE__ */ jsx("div", {
+		className: style_default.SnippetCode,
+		"data-stldocs-copy-content": true,
+		dangerouslySetInnerHTML: { __html: highlighted }
+	});
+}
+function SnippetContainer({ children }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: clsx(style_default.Snippet),
+		children
+	});
+}
+function SnippetRequestContainer({ children }) {
+	return /* @__PURE__ */ jsx("div", { children });
+}
+function Snippet({ requestTitle, method, transformRequestSnippet }) {
+	const Docs = useComponents();
+	const language = useLanguage();
+	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;
+	const httpMethod = getHttpMethod(method.httpMethod);
+	return /* @__PURE__ */ jsxs(Docs.SnippetContainer, {
+		signature,
+		method,
+		children: [snippet && /* @__PURE__ */ jsx(Docs.SnippetRequestContainer, {
+			signature,
+			children: /* @__PURE__ */ jsxs("div", {
+				className: style_default.SnippetRequest,
+				"data-stldocs-copy-parent": true,
+				children: [
+					/* @__PURE__ */ jsxs("div", {
+						className: style_default.SnippetRequestTitle,
+						children: [
+							/* @__PURE__ */ jsxs("div", {
+								className: style_default.SnippetRequestTitleMethod,
+								children: [httpMethod && /* @__PURE__ */ jsx(Badge.HTTP, {
+									method: httpMethod,
+									iconOnly: true
+								}), /* @__PURE__ */ jsx("h3", { children: method.summary ?? method.title })]
+							}),
+							/* @__PURE__ */ jsx("div", {
+								className: style_default.SnippetRequestTitleContent,
+								children: requestTitle
+							}),
+							/* @__PURE__ */ jsx(Docs.SnippetButtons, { content: snippet })
+						]
+					}),
+					/* @__PURE__ */ jsx(Docs.SnippetCode, {
+						content: snippet,
+						signature
+					}),
+					/* @__PURE__ */ jsx(Docs.SnippetFooter, {})
+				]
+			})
+		}), responses && /* @__PURE__ */ jsx(Docs.SnippetResponse, { responses })]
+	});
+}
+function SnippetButtons({ content }) {
+	const [CopyButtonIcon, setCopyIcon] = React$1.useState(CopyIcon);
+	async function handleCopy() {
+		try {
+			await navigator.clipboard.writeText(content);
+			setCopyIcon(CheckIcon);
+		} catch {
+			setCopyIcon(CircleAlertIcon);
+		}
+		setTimeout(() => setCopyIcon(CopyIcon), 1e3);
+	}
+	return /* @__PURE__ */ jsx(Button, {
+		variant: "outline",
+		"data-stldocs-snippet-copy": true,
+		children: /* @__PURE__ */ jsx(CopyButtonIcon, {
+			size: 16,
+			className: style_default.Icon,
+			onClick: handleCopy
+		})
+	});
+}
+function SnippetFooter() {
+	return null;
+}
+function SnippetResponse({ responses }) {
+	const { SnippetCode } = 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;
+		let language = "none";
+		if (responseType === "application/json" || typeof value === "object") {
+			language = "json";
+			value = JSON.stringify(value, null, 2);
+		}
+		return {
+			language,
+			responseCode: key,
+			content: value
+		};
+	}).filter(Boolean);
+	if (mappedResponses.length === 0) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: style_default.SnippetMultiResponse,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: clsx(style_default.Snippet),
+			children: [/* @__PURE__ */ jsx("div", {
+				className: clsx(style_default.SnippetResponseTab, mappedResponses.length === 1 && style_default.SnippetResponseTabSingleReturn),
+				children: mappedResponses.map(({ responseCode }, index) => /* @__PURE__ */ jsx("div", {
+					"data-snippet-response-tab-id": `snippet-response-tab-${responseCode}-${index}`,
+					className: clsx(style_default.SnippetResponseTabItem, index === 0 && style_default.SnippetResponseTabItemActive),
+					children: /* @__PURE__ */ jsxs(Button, {
+						disabled: mappedResponses.length === 1,
+						variant: "ghost",
+						children: [responseCode, " example"]
+					})
+				}, `snippet-response-tab-item-${responseCode}-${index}`))
+			}), mappedResponses.map(({ responseCode, content, language }, index) => {
+				return /* @__PURE__ */ jsx("div", {
+					className: clsx(style_default.SnippetResponsePane, index === 0 && style_default.SnippetResponsePaneActive),
+					"data-snippet-response-pane-id": `snippet-response-tab-${responseCode}-${index}`,
+					children: /* @__PURE__ */ jsx(SnippetCode, {
+						content,
+						language
+					})
+				}, `snippet-response-${responseCode}-${index}`);
+			})]
+		})
+	});
+}
+
+//#endregion
+export { SnippetFooter as a, SnippetContainer as i, SnippetButtons as n, SnippetRequestContainer as o, SnippetCode as r, SnippetResponse as s, Snippet as t };

package/dist/spec.d.ts

@@ -0,0 +1,65 @@
+import { f as Resource, g as SpecLanguage, h as Spec, l as Method, r as DeclarationNode, u as Model } from "./index-zNpvNvtN.js";
+import { t as DocsLanguage } from "./routing-CtbZJru_.js";
+
+//#region src/spec.d.ts
+type SecurityScheme = Spec['security_schemes'][number];
+interface SpecTransforms {
+  resource(resource: Resource): Resource;
+  method(method: Method): Method;
+  model(model: Model): Model;
+  declaration(decl: DeclarationNode, language: SpecLanguage): DeclarationNode;
+  securityScheme(scheme: SecurityScheme): SecurityScheme;
+  snippet(snippet: string, language: string): string;
+  markdown(content?: string): string | undefined;
+}
+declare function defineTransforms(transforms?: Partial<SpecTransforms>): {
+  resource: (resource: Resource) => Resource;
+  method: (method: Method) => Method;
+  model: (model: Model) => Model;
+  declaration: (decl: DeclarationNode, language: SpecLanguage) => DeclarationNode;
+  securityScheme: (scheme: SecurityScheme) => SecurityScheme;
+  snippet: (snippet: string, language: string) => string;
+  markdown: (content?: string) => string | undefined;
+};
+declare function generateNavigation(resource: Partial<Resource>): {
+  title: string | undefined;
+  name: string | undefined;
+  subresources: Record<string, Partial<Resource>> | undefined;
+  methods: Record<string, Partial<Method>> | undefined;
+  models: Record<string, Partial<Model>> | undefined;
+  stainlessPath: string | undefined;
+  terraform: {
+    Name: string;
+    QualifiedName: string;
+  } | undefined;
+};
+declare function generateSpecForResource(spec: Spec, name: string, lang: DocsLanguage, transforms: SpecTransforms): Partial<Spec>;
+declare function transform(spec: Spec, transforms: SpecTransforms): {
+  name: string;
+  lang: "cli" | "csharp" | "go" | "http" | "java" | "kotlin" | "node" | "php" | "python" | "ruby" | "terraform" | "typescript";
+  spec: Partial<Spec>;
+}[];
+declare function split(spec: Spec, transforms?: SpecTransforms): {
+  resources: ReturnType<typeof transform>;
+  navigation: {
+    languages: ("go" | "http" | "java" | "kotlin" | "node" | "python" | "ruby" | "terraform" | "typescript")[] | undefined;
+    resources: {
+      [k: string]: {
+        title: string | undefined;
+        name: string | undefined;
+        subresources: Record<string, Partial<Resource>> | undefined;
+        methods: Record<string, Partial<Method>> | undefined;
+        models: Record<string, Partial<Model>> | undefined;
+        stainlessPath: string | undefined;
+        terraform: {
+          Name: string;
+          QualifiedName: string;
+        } | undefined;
+      };
+    };
+  };
+};
+declare function parseSpec(content: string): Spec | undefined;
+declare function retrieve(apiKey: string, project: string, revision: string): Promise<Spec | undefined>;
+//#endregion
+export { SecurityScheme, SpecTransforms, defineTransforms, generateNavigation, generateSpecForResource, parseSpec, retrieve, split, transform };

package/dist/spec.js

@@ -0,0 +1,167 @@
+import { n as Languages } from "./routing-Ce0_tBW6.js";
+import { r as isResourceEmpty } from "./utils-D01mAUfQ.js";
+
+//#region src/spec.ts
+const defaultTransforms = {
+	resource: (resource) => resource,
+	method: (method) => method,
+	model: (model) => model,
+	declaration: (decl) => decl,
+	securityScheme: (scheme) => scheme,
+	snippet: (snippet) => snippet,
+	markdown: (content) => content
+};
+function defineTransforms(transforms = {}) {
+	return {
+		...defaultTransforms,
+		...transforms
+	};
+}
+function removeStudioRefs(obj) {
+	if (typeof obj !== "object" || obj === null) return obj;
+	if (Array.isArray(obj)) return obj.map(removeStudioRefs);
+	const newObj = {};
+	for (const [key, value] of Object.entries(obj)) if (key !== "oasRef" && key !== "configRef") newObj[key] = removeStudioRefs(value);
+	return newObj;
+}
+function mapEntries({ input, fn, filter }) {
+	if (!input) return;
+	const output = {};
+	for (const [name, entry] of Object.entries(input)) {
+		if (filter && !filter(name, entry)) continue;
+		output[name] = fn ? fn(entry) : entry;
+	}
+	return output;
+}
+function transformRecursively(resource, transforms) {
+	return {
+		...transforms.resource(resource),
+		methods: mapEntries({
+			input: resource.methods,
+			fn: (method) => transforms.method(method)
+		}) ?? {},
+		models: mapEntries({
+			input: resource.models,
+			fn: (model) => transforms.model(model)
+		}) ?? {},
+		subresources: mapEntries({
+			input: resource.subresources,
+			fn: (sub) => transformRecursively(sub, transforms)
+		}) ?? {}
+	};
+}
+function generateNavigation(resource) {
+	const { title, name, stainlessPath, terraform } = resource;
+	return {
+		title,
+		name,
+		subresources: mapEntries({
+			input: resource.subresources,
+			fn: generateNavigation
+		}),
+		methods: mapEntries({
+			input: resource.methods,
+			fn: (method) => ({
+				name: method.name,
+				stainlessPath: method.stainlessPath,
+				summary: method.summary,
+				httpMethod: method.httpMethod
+			})
+		}),
+		models: mapEntries({
+			input: resource.models,
+			fn: (model) => ({
+				name: model.name,
+				stainlessPath: model.stainlessPath
+			})
+		}),
+		stainlessPath,
+		terraform
+	};
+}
+function generateSpecForResource(spec, name, lang, transforms) {
+	const resource = spec.resources[name];
+	if (!resource) throw new Error(`Invalid resource: ${name}`);
+	return {
+		resources: {
+			[name]: transformRecursively(resource, transforms),
+			...spec.resources["$shared"] ? { $shared: transformRecursively(spec.resources["$shared"], transforms) } : {}
+		},
+		security_schemes: spec.security_schemes?.map((scheme) => transforms.securityScheme(scheme)),
+		decls: { [lang]: mapEntries({
+			input: spec.decls[lang] ?? {},
+			filter: (name) => name.startsWith(resource.stainlessPath) || name.startsWith("(resource) $shared"),
+			fn: (decl) => transforms.declaration(decl, lang)
+		}) },
+		snippets: mapEntries({
+			input: spec.snippets,
+			filter: (name) => name.startsWith(lang),
+			fn: (snippets) => mapEntries({
+				input: snippets,
+				filter: (name) => name.startsWith(resource.stainlessPath),
+				fn: (snippet) => transforms.snippet(snippet, lang)
+			}) ?? {}
+		})
+	};
+}
+function transform(spec, transforms) {
+	const t = {
+		...transforms,
+		declaration: (decl, lang) => transforms.declaration({
+			...decl,
+			..."docstring" in decl ? { docstring: transforms.markdown(decl.docstring) } : {}
+		}, lang),
+		method: (method) => transforms.method({
+			...method,
+			description: transforms.markdown(method.description),
+			deprecated: typeof method.deprecated === "string" ? transforms.markdown(method.deprecated) : method.deprecated
+		}),
+		securityScheme: (scheme) => transforms.securityScheme({
+			...scheme,
+			description: transforms.markdown(scheme.description)
+		})
+	};
+	const output = [];
+	for (const lang of Languages) for (const [name, resource] of Object.entries(spec.resources)) {
+		if (isResourceEmpty(resource)) continue;
+		output.push({
+			name,
+			lang,
+			spec: generateSpecForResource(spec, name, lang, t)
+		});
+	}
+	return output;
+}
+function split(spec, transforms) {
+	return {
+		resources: transform(spec, transforms ?? defineTransforms()).map(removeStudioRefs),
+		navigation: {
+			languages: spec.docs?.languages,
+			resources: Object.fromEntries(Object.entries(spec.resources).filter(([, res]) => !isResourceEmpty(res)).map(([name, res]) => [name, generateNavigation(res)]))
+		}
+	};
+}
+function parseSpec(content) {
+	const parsed = JSON.parse(content);
+	if (parsed && typeof parsed === "object" && "kind" in parsed && parsed.kind === "spec") return parsed;
+}
+async function retrieve(apiKey, project, revision) {
+	const data = await (await fetch("https://app.stainless.com/api/generate/spec", {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${apiKey}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			project,
+			source: {
+				type: "git",
+				revision
+			}
+		})
+	})).json();
+	if (typeof data.spec === "string") return parseSpec(data.spec);
+}
+
+//#endregion
+export { defineTransforms, generateNavigation, generateSpecForResource, parseSpec, retrieve, split, transform };

package/dist/style-LwfvXElj.js

@@ -0,0 +1,170 @@
+//#region src/style.ts
+var style_default = {
+	TextIdentifier: "stldocs-text-identifier",
+	TextOperator: "stldocs-text-operator",
+	TextPunctuation: "stldocs-text-punctuation",
+	TextKeyword: "stldocs-text-keyword",
+	ContentArea: "stldocs-content-area",
+	Markdown: "stldocs-markdown",
+	Content: "stldocs-content",
+	Truncation: "stldocs-truncation",
+	Expander: "stldocs-expander",
+	ExpanderContent: "stldocs-expander-content",
+	ExpanderSummary: "stldocs-expander-summary",
+	ExpanderSummaryIcon: "stldocs-expander-summary-icon",
+	ExpanderSummaryContent: "stldocs-expander-summary-content",
+	ExpanderIndent: "stldocs-expander-indent",
+	Badge: "stldocs-badge",
+	Icon: "stldocs-icon",
+	Tooltip: "stldocs-tooltip",
+	TooltipHost: "stldocs-tooltip-host",
+	TooltipContent: "stldocs-tooltip-content",
+	Input: "stldocs-input",
+	InputDisabled: "stldocs-input-disabled",
+	InputTextField: "stldocs-input-textfield",
+	MaskedInputWrapper: "stldocs-masked-input-wrapper",
+	MaskedInputDisplay: "stldocs-masked-input-display",
+	MaskedInputObscured: "stldocs-masked-input-obscured",
+	ToggleButton: "stldocs-togglebutton",
+	ListView: "stldocs-listview",
+	ListViewItem: "stldocs-listview-item",
+	ExpandToggle: "stldocs-expand-toggle",
+	ExpandToggleContent: "stldocs-expand-toggle-content",
+	LoadingSpinner: "stldocs-loading-spinner",
+	Type: "stldocs-type",
+	TypeName: "stldocs-typename",
+	TypeKeyword: "stldocs-type-keyword",
+	TypeString: "stldocs-type-string",
+	TypeArray: "stldocs-type-array",
+	TypeReference: "stldocs-type-reference",
+	TypeBracket: "stldocs-type-bracket",
+	TypeBrace: "stldocs-type-brace",
+	TypePropertyName: "stldocs-type-propertyname",
+	TypePlain: "stldocs-type-plain",
+	TypePreview: "stldocs-type-preview",
+	TypePreviewContent: "stldocs-type-preview-content",
+	LiteralString: "stldocs-literal-string",
+	LiteralNumeric: "stldocs-literal-numeric",
+	LiteralBoolean: "stldocs-literal-boolean",
+	Snippet: "stldocs-snippet",
+	SnippetCode: "stldocs-snippet-code",
+	SnippetFooter: "stldocs-snippet-footer",
+	SnippetRequest: "stldocs-snippet-request",
+	SnippetRequestTitle: "stldocs-snippet-request-title",
+	SnippetRequestTitleContent: "stldocs-snippet-request-title-content",
+	SnippetRequestTitleLabel: "stldocs-snippet-request-title-label",
+	SnippetRequestTitleLanguage: "stldocs-snippet-request-title-language",
+	SnippetRequestTitleMethod: "stldocs-snippet-request-title-method",
+	SnippetResponse: "stldocs-snippet-response",
+	SnippetMultiResponse: "stldocs-snippet-multi-response",
+	SnippetResponseOpen: "stldocs-snippet-response-opened",
+	SnippetResponseTab: "stldocs-snippet-response-tab",
+	SnippetResponseTabItem: "stldocs-snippet-response-tab-item",
+	SnippetResponseTabItemActive: "stldocs-snippet-response-tab-item-active",
+	SnippetResponseTabSingleReturn: "stldocs-snippet-response-tab-single-return",
+	SnippetResponsePane: "stldocs-snippet-response-pane",
+	SnippetResponsePaneActive: "stldocs-snippet-response-pane-active",
+	Method: "stldocs-method",
+	MethodHeader: "stldocs-method-header",
+	MethodBody: "stldocs-method-body",
+	MethodInfo: "stldocs-method-info",
+	MethodInfoSection: "stldocs-method-info-section",
+	MethodExample: "stldocs-method-example",
+	MethodResponseColumn: "stldocs-method-response-column",
+	MethodTitle: "stldocs-method-title",
+	MethodBadges: "stldocs-method-badges",
+	MethodSignature: "stldocs-method-signature",
+	MethodDescription: "stldocs-method-description",
+	MethodParameters: "stldocs-method-parameters",
+	MethodReturns: "stldocs-method-returns",
+	MethodContent: "stldocs-method-content",
+	MethodContentColumn: "stldocs-method-content-column",
+	MethodRouteEndpoint: "stldocs-method-route-endpoint",
+	MethodRoute: "stldocs-method-route",
+	MethodSummary: "stldocs-method-summary",
+	MethodSinglePane: "stldocs-method-single-pane",
+	MethodDoublePane: "stldocs-method-double-pane",
+	SignatureTitle: "stldocs-signature-title",
+	SignatureName: "stldocs-signature-name",
+	SignatureQualified: "stldocs-signature-qualified",
+	SignatureParams: "stldoc-signature-params",
+	SignatureParen: "stldocs-signature-paren",
+	SignatureReturns: "stldocs-signature-returns",
+	Property: "stldocs-property",
+	Properties: "stldocs-properties",
+	PropertyHeader: "stldocs-property-header",
+	PropertyInfo: "stldocs-property-info",
+	PropertyDeclaration: "stldocs-property-declaration",
+	PropertyDeprecated: "stldocs-property-deprecated",
+	PropertyDeprecatedMessage: "stldocs-property-deprecated-message",
+	PropertyContent: "stldocs-property-content",
+	PropertyChildren: "stldocs-property-children",
+	PropertyConstraints: "stldocs-property-constraints",
+	PropertyConstraint: "stldocs-property-constraint",
+	PropertyConstraintName: "stldocs-property-constraint-name",
+	PropertyConstraintValue: "stldocs-property-constraint-value",
+	PropertyDefault: "stldocs-property-default",
+	PropertyDescription: "stldocs-property-description",
+	PropertyTitle: "stldocs-property-title",
+	PropertyAnnotation: "stldocs-property-annotation",
+	PropertyName: "stldocs-property-name",
+	PropertyBadges: "stldocs-property-badges",
+	PropertyTypeName: "stldocs-property-typename",
+	PropertyType: "stldocs-property-type",
+	Overview: "stldocs-overview",
+	OverviewHeader: "stldocs-overview-header",
+	OverviewHeaderInfo: "stldocs-overview-header-info",
+	OverviewHeaderInfoTimestamp: "stldocs-overview-header-info-timestamp",
+	Resource: "stldocs-resource",
+	ResourceContent: "stldocs-resource-content",
+	ResourceContentProperties: "stldocs-resource-content-properties",
+	ResourceContentGroup: "stldocs-resource-content-group",
+	ResourceContentGroupName: "stldocs-resource-content-group-name",
+	ResourceContentGroupModelTitle: "stldocs-resource-content-group-model-title",
+	ResourceHeader: "stldocs-resource-header",
+	ResourceTitle: "stldocs-resource-title",
+	ResourceTitleSegment: "stldocs-resource-title-segment",
+	ResourceDescription: "stldocs-resource-description",
+	ResourceName: "stldocs-resource-name",
+	Model: "stldocs-model",
+	Root: "stldocs-root",
+	Sidebar: "stldocs-sidebar",
+	SidebarResource: "stldocs-sidebar-resource",
+	SidebarResourceTitle: "stldocs-sidebar-resource-title",
+	SidebarMethod: "stldocs-sidebar-method",
+	SidebarItemTitle: "stldocs-sidebar-resource-title",
+	SidebarExpander: "stldocs-sidebar-expander",
+	SidebarExpanderSummary: "stldocs-sidebar-expander-summary",
+	SidebarExpanderContent: "stldocs-sidebar-expander-content",
+	SearchForm: "stldocs-search-form",
+	SearchModal: "stldocs-search-modal",
+	SearchFilter: "stldocs-search-filter",
+	SearchFilterLabel: "stldocs-search-filter-label",
+	SearchFilterCount: "stldocs-search-filter-count",
+	SearchBreadcrumb: "stldocs-search-breadcrumb",
+	SearchBreadcrumbItem: "stldocs-search-breadcrumb-item",
+	SearchBreadcrumbDivider: "stldocs-search-breadcrumb-divider",
+	SearchResult: "stldocs-search-result",
+	SearchResultResourceInfo: "stldocs-search-result-resource-info",
+	SearchResultResourceTitle: "stldocs-search-result-resource-title",
+	SearchResultResourcePath: "stldocs-search-result-resource-path",
+	SearchResultGuideTitle: "stldocs-search-result-guide-title",
+	SearchResultGuideExcerpt: "stldocs-search-result-guide-excerpt",
+	SearchDisabledStateContainer: "stldocs-search-disabled-state-container",
+	SearchModalCloseButton: "stldocs-search-modal-close-button",
+	LanguageBlock: "stldocs-language-block",
+	LanguageBlockContent: "stldocs-language-block-content",
+	LanguageBlockContentIcon: "stldocs-language-block-content-icon",
+	LanguageBlockContentInfo: "stldocs-language-block-content-info",
+	LanguageBlockContentInfoLanguage: "stldocs-language-block-content-info-language",
+	LanguageBlockContentInfoVersion: "stldocs-language-block-content-info-version",
+	LanguageBlockLinks: "stldocs-language-block-links",
+	LanguageBlockInstall: "stldocs-language-block-install",
+	Breadcrumbs: "stldocs-breadcrumbs",
+	BreadcrumbsItem: "stldocs-breadcrumbs-item",
+	BreadcrumbsLink: "stldocs-breadcrumbs-link",
+	BreadcrumbsNonLink: "stldocs-breadcrumbs-non-link"
+};
+
+//#endregion
+export { style_default as t };