@stainless-api/docs-ui 0.1.0-beta.4 → 0.1.0-beta.40

package/dist/spec.d.ts

@@ -0,0 +1,65 @@
+import { t as DocsLanguage } from "./routing-DNN8R6bZ.js";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/spec.d.ts
+type SecurityScheme = SDKJSON.Spec['security_schemes'][number];
+interface SpecTransforms {
+  resource(resource: SDKJSON.Resource): SDKJSON.Resource;
+  method(method: SDKJSON.Method): SDKJSON.Method;
+  model(model: SDKJSON.Model): SDKJSON.Model;
+  declaration(decl: SDKJSON.DeclarationNode, language: SDKJSON.SpecLanguage): SDKJSON.DeclarationNode;
+  securityScheme(scheme: SecurityScheme): SecurityScheme;
+  snippet(snippet: string, language: string): string;
+  markdown(content?: string): string | undefined;
+}
+declare function defineTransforms(transforms?: Partial<SpecTransforms>): {
+  resource: (resource: SDKJSON.Resource) => SDKJSON.Resource;
+  method: (method: SDKJSON.Method) => SDKJSON.Method;
+  model: (model: SDKJSON.Model) => SDKJSON.Model;
+  declaration: (decl: SDKJSON.DeclarationNode, language: SDKJSON.SpecLanguage) => SDKJSON.DeclarationNode;
+  securityScheme: (scheme: SecurityScheme) => SecurityScheme;
+  snippet: (snippet: string, language: string) => string;
+  markdown: (content?: string) => string | undefined;
+};
+declare function generateNavigation(resource: Partial<SDKJSON.Resource>): {
+  title: string | undefined;
+  name: string | undefined;
+  subresources: Record<string, Partial<SDKJSON.Resource>> | undefined;
+  methods: Record<string, Partial<SDKJSON.Method>> | undefined;
+  models: Record<string, Partial<SDKJSON.Model>> | undefined;
+  stainlessPath: string | undefined;
+  terraform: {
+    Name: string;
+    QualifiedName: string;
+  } | undefined;
+};
+declare function generateSpecForResource(spec: SDKJSON.Spec, name: string, lang: DocsLanguage, transforms: SpecTransforms): Partial<SDKJSON.Spec>;
+declare function transform(spec: SDKJSON.Spec, transforms: SpecTransforms): {
+  name: string;
+  lang: "node" | "go" | "python" | "terraform" | "http" | "typescript" | "ruby" | "java" | "kotlin";
+  spec: Partial<SDKJSON.Spec>;
+}[];
+declare function split(spec: SDKJSON.Spec, transforms?: SpecTransforms): {
+  resources: ReturnType<typeof transform>;
+  navigation: {
+    languages: ("node" | "go" | "python" | "terraform" | "http" | "typescript" | "ruby" | "java" | "kotlin")[] | undefined;
+    resources: {
+      [k: string]: {
+        title: string | undefined;
+        name: string | undefined;
+        subresources: Record<string, Partial<SDKJSON.Resource>> | undefined;
+        methods: Record<string, Partial<SDKJSON.Method>> | undefined;
+        models: Record<string, Partial<SDKJSON.Model>> | undefined;
+        stainlessPath: string | undefined;
+        terraform: {
+          Name: string;
+          QualifiedName: string;
+        } | undefined;
+      };
+    };
+  };
+};
+declare function parseSpec(content: string): SDKJSON.Spec | undefined;
+declare function retrieve(apiKey: string, project: string, revision: string): Promise<SDKJSON.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-qs2YNG9o.js";
+import { r as isResourceEmpty } from "./utils-FnJ4tyuN.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$1) => name$1.startsWith(resource.stainlessPath) || name$1.startsWith("(resource) $shared"),
+			fn: (decl) => transforms.declaration(decl, lang)
+		}) },
+		snippets: mapEntries({
+			input: spec.snippets,
+			filter: (name$1) => name$1.startsWith(lang),
+			fn: (snippets) => mapEntries({
+				input: snippets,
+				filter: (name$1) => name$1.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-BhhgPVF6.js

@@ -0,0 +1,165 @@
+//#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",
+	InputTextField: "stldocs-input-textfield",
+	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",
+	SnippetCodeContent: "stldocs-snippet-code-content",
+	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",
+	MethodRouteHttpMethod: "stldocs-method-route-httpmethod",
+	MethodRouteHttpMethodIconOnly: "stldocs-method-route-httpmethod-icon-only",
+	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",
+	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",
+	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 };

package/dist/style-p4qTfnmO.d.ts

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

package/dist/style.d.ts

@@ -0,0 +1,2 @@
+import { t as _default } from "./style-p4qTfnmO.js";
+export { _default as default };

package/dist/style.js

@@ -0,0 +1,3 @@
+import { t as style_default } from "./style-BhhgPVF6.js";
+
+export { style_default as default };