@stainless-api/docs-ui 0.1.0-beta.10 → 0.1.0-beta.11

package/dist/search/providers/algolia.js

@@ -1,64 +1,16 @@
-import { searchClient } from '@algolia/client-search';
-import { generateChatIndex, generateIndex } from '../indexer';
-import { SearchableAttributes, SearchableAttributesChat } from '../types';
-export async function buildIndex(appId, indexName, writeKey, spec, renderMarkdown) {
-    if (!appId || !indexName || !writeKey)
-        return;
-    const objects = Array.from(generateIndex(spec, renderMarkdown));
-    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 });
-}
-export 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 });
-}
-export async function search({ settings: { appId, indexName, searchKey }, params: { query, language, kind }, }) {
-    const client = searchClient(appId, searchKey);
-    const filters = language ? `language:${language}` : undefined;
-    const facetFilters = kind ? [`kind:${kind}`] : undefined;
-    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, facets };
-    }
-}
-//# sourceMappingURL=algolia.js.map
+import "../../component-generics-DzI21jRn.js";
+import "../../docs-Dh8kE1va.js";
+import "../../navigation-aoYZ_tl4.js";
+import "../../markdown-BXfX1D7C.js";
+import "../../routing-DQjbRxdJ.js";
+import "../../style-rYbbxIR_.js";
+import "../../use-components-D9E85p5x.js";
+import { c as search, o as buildChatIndex, s as buildIndex } from "../../contexts-DRxRO-xO.js";
+import "../../icons-DdKM-01E.js";
+import "../../utils-CJfFBNgT.js";
+import "../../dropdown-DtgAi6lb.js";
+import "../../md-Dg8aOyMA.js";
+import "../../utils-BHwvUDKn.js";
+import "../../types-DFN4M1Sp.js";
+
+export { buildChatIndex, buildIndex, search };

package/dist/search/providers/fuse.d.ts

@@ -1,10 +1,17 @@
-import { FuseIndex } from 'fuse.js';
-import { DocsLanguage } from '../../routing';
-import { IndexEntry } from '../types';
-import type { SDKJSON } from '../../types/sdkjson';
-export type FuseIndexData = {
-    content: IndexEntry[];
-    index: FuseIndex<IndexEntry>;
+import { t as DocsLanguage } from "../../routing-qc0V00-j.js";
+import { n as IndexEntry } from "../../types-CTBDtD34.js";
+import * as fuse_js0 from "fuse.js";
+import { FuseIndex } from "fuse.js";
+
+//#region src/search/providers/fuse.d.ts
+type FuseIndexData = {
+  content: IndexEntry[];
+  index: FuseIndex<IndexEntry>;
 };
-export declare function buildIndex(spec: SDKJSON.Spec, language?: DocsLanguage): FuseIndexData;
-export declare function search({ content, index }: FuseIndexData, query: string, limit?: number): import("fuse.js").FuseResult<IndexEntry>[];
+declare function buildIndex(spec: SDKJSON.Spec, language?: DocsLanguage): FuseIndexData;
+declare function search({
+  content,
+  index
+}: FuseIndexData, query: string, limit?: number): fuse_js0.FuseResult<IndexEntry>[];
+//#endregion
+export { FuseIndexData, buildIndex, search };

package/dist/search/providers/fuse.js

@@ -1,14 +1,31 @@
-import Fuse from 'fuse.js';
-import { generateIndex } from '../indexer';
-import { SearchableAttributes } from '../types';
-export function buildIndex(spec, language) {
-    const idx = Array.from(generateIndex(spec, null, false));
-    const content = language ? idx.filter((entry) => entry.language === language) : idx;
-    const index = Fuse.createIndex(SearchableAttributes, content);
-    return { content, index };
+import "../../component-generics-DzI21jRn.js";
+import "../../docs-Dh8kE1va.js";
+import "../../navigation-aoYZ_tl4.js";
+import "../../markdown-BXfX1D7C.js";
+import "../../routing-DQjbRxdJ.js";
+import "../../style-rYbbxIR_.js";
+import "../../use-components-D9E85p5x.js";
+import { l as generateIndex } from "../../contexts-DRxRO-xO.js";
+import "../../icons-DdKM-01E.js";
+import "../../utils-CJfFBNgT.js";
+import "../../dropdown-DtgAi6lb.js";
+import "../../md-Dg8aOyMA.js";
+import "../../utils-BHwvUDKn.js";
+import { n as SearchableAttributes } from "../../types-DFN4M1Sp.js";
+import Fuse from "fuse.js";
+
+//#region src/search/providers/fuse.ts
+function buildIndex(spec, language) {
+	const idx = Array.from(generateIndex(spec, null, false));
+	const content = language ? idx.filter((entry) => entry.language === language) : idx;
+	return {
+		content,
+		index: Fuse.createIndex(SearchableAttributes, content)
+	};
 }
-export function search({ content, index }, query, limit = 100) {
-    const fuse = new Fuse(content, { keys: SearchableAttributes }, index);
-    return fuse.search(query).slice(0, limit);
+function search({ content, index }, query, limit = 100) {
+	return new Fuse(content, { keys: SearchableAttributes }, index).search(query).slice(0, limit);
 }
-//# sourceMappingURL=fuse.js.map
+
+//#endregion
+export { buildIndex, search };

package/dist/search/providers/pagefind.d.ts

@@ -1,2 +1,7 @@
-import type { GuideResultType } from '../types';
-export declare function guideSearch(loadPath: string, query: string, limit?: number): Promise<GuideResultType[]>;
+import "../../routing-qc0V00-j.js";
+import { t as GuideResultType } from "../../types-CTBDtD34.js";
+
+//#region src/search/providers/pagefind.d.ts
+declare function guideSearch(loadPath: string, query: string, limit?: number): Promise<GuideResultType[]>;
+//#endregion
+export { guideSearch };

package/dist/search/providers/pagefind.js

@@ -1,19 +1,3 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-async function loadPagefind(path) {
-    const url = new URL(path, import.meta.url).href;
-    return await import(__rewriteRelativeImportExtension(/* @vite-ignore */ url));
-}
-export async function guideSearch(loadPath, query, limit) {
-    const index = await loadPagefind(loadPath);
-    const response = await index.search(query);
-    const items = limit ? response.results.slice(0, limit) : response.results;
-    return Promise.all(items.map((result) => result.data().then((data) => ({ ...result, data }))));
-}
-//# sourceMappingURL=pagefind.js.map
+import { t as guideSearch } from "../../pagefind-ChrPfuVv.js";
+
+export { guideSearch };

package/dist/search/providers/walker.d.ts

@@ -1,5 +1,8 @@
-import { DocsLanguage } from '../../routing';
-import { IndexEntry } from '../types';
-import type { SDKJSON } from '../../types/sdkjson';
-export declare function buildIndex(spec: SDKJSON.Spec): Generator<IndexEntry, any, any>;
-export declare function search(index: Generator<IndexEntry>, language: DocsLanguage, query: string, limit?: number): IndexEntry[];
+import { t as DocsLanguage } from "../../routing-qc0V00-j.js";
+import { n as IndexEntry } from "../../types-CTBDtD34.js";
+
+//#region src/search/providers/walker.d.ts
+declare function buildIndex(spec: SDKJSON.Spec): Generator<IndexEntry, any, any>;
+declare function search(index: Generator<IndexEntry>, language: DocsLanguage, query: string, limit?: number): IndexEntry[];
+//#endregion
+export { buildIndex, search };

package/dist/search/providers/walker.js

@@ -1,23 +1,32 @@
-import { generateIndex } from '../indexer';
-import { SearchableAttributes } from '../types';
-export function buildIndex(spec) {
-    return generateIndex(spec, null, false);
+import "../../component-generics-DzI21jRn.js";
+import "../../docs-Dh8kE1va.js";
+import "../../navigation-aoYZ_tl4.js";
+import "../../markdown-BXfX1D7C.js";
+import "../../routing-DQjbRxdJ.js";
+import "../../style-rYbbxIR_.js";
+import "../../use-components-D9E85p5x.js";
+import { l as generateIndex } from "../../contexts-DRxRO-xO.js";
+import "../../icons-DdKM-01E.js";
+import "../../utils-CJfFBNgT.js";
+import "../../dropdown-DtgAi6lb.js";
+import "../../md-Dg8aOyMA.js";
+import "../../utils-BHwvUDKn.js";
+import { n as SearchableAttributes } from "../../types-DFN4M1Sp.js";
+
+//#region src/search/providers/walker.ts
+function buildIndex(spec) {
+	return generateIndex(spec, null, false);
 }
 function* findEntryInIndex(index, language, query) {
-    for (const entry of index) {
-        if (entry.language !== language)
-            continue;
-        for (const attr of SearchableAttributes) {
-            if (entry[attr] && typeof entry[attr] === 'string' && entry[attr].includes(query))
-                yield entry;
-        }
-    }
+	for (const entry of index) {
+		if (entry.language !== language) continue;
+		for (const attr of SearchableAttributes) if (entry[attr] && typeof entry[attr] === "string" && entry[attr].includes(query)) yield entry;
+	}
 }
-export function search(index, language, query, limit = 100) {
-    const results = findEntryInIndex(index, language, query);
-    const sorted = Array.from(results)
-        .sort((a, b) => a.priority - b.priority)
-        .slice(0, limit);
-    return sorted;
+function search(index, language, query, limit = 100) {
+	const results = findEntryInIndex(index, language, query);
+	return Array.from(results).sort((a, b) => a.priority - b.priority).slice(0, limit);
 }
-//# sourceMappingURL=walker.js.map
+
+//#endregion
+export { buildIndex, search };

package/dist/search/types.d.ts

@@ -1,79 +1,3 @@
-import type { SDKJSON } from '../types/sdkjson';
-import { DocsLanguage } from '../routing';
-export type SearchSettings = {
-    appId: string;
-    searchKey: string;
-    indexName: string;
-    assistant?: string;
-};
-export type SearchParams = {
-    query: string;
-    language?: DocsLanguage | null;
-    kind?: QueryKindsType | null;
-};
-export declare const QueryKinds: readonly ["all", "resource", "http_method", "model", "property", "guide"];
-export type QueryKindsType = (typeof QueryKinds)[number];
-export type IndexModel = {
-    kind: 'model';
-    title: string;
-    children?: string[];
-    ident?: string;
-};
-export type IndexProperty = {
-    kind: 'property';
-    docstring?: string;
-    type?: string;
-};
-export type IndexResource = {
-    kind: 'resource';
-    title: string;
-    Name: string;
-    QualifiedName: string;
-};
-export type IndexMethod = Pick<SDKJSON.Method, 'kind' | 'summary' | 'description' | 'endpoint' | 'httpMethod'> & {
-    title: string;
-    qualified?: string;
-    ident?: string;
-};
-export declare const SearchableAttributes: string[];
-export declare const SearchableAttributesChat: string[];
-export type SearchAttributeNames = (typeof SearchableAttributes)[number];
-export type RoutableJsonNode = SDKJSON.Method | SDKJSON.Model | SDKJSON.Resource;
-export type IndexEntry = Pick<RoutableJsonNode, 'name' | 'stainlessPath'> & (IndexProperty | IndexModel | IndexResource | IndexMethod) & {
-    language: DocsLanguage;
-    priority: number;
-    crumbs: string[];
-};
-export type ResultRecordType = IndexEntry & {
-    objectID: string;
-    _highlightResult: Record<SearchAttributeNames, {
-        value: string;
-    }>;
-};
-export type ResultType = {
-    hits: ResultRecordType[];
-    facets?: Record<string, Record<string, number>>;
-    nbHits: number;
-};
-export type GuideResultType = {
-    id: string;
-    score: number;
-    words: number[];
-    data: {
-        excerpt: string;
-        url: string;
-        word_count: number;
-        meta: {
-            title: string;
-        };
-        sub_results: {
-            url: string;
-            title: string;
-            excerpt: string;
-        }[];
-    };
-};
-export type ResultData = {
-    items: Array<ResultRecordType | GuideResultType>;
-    counts: Partial<Record<QueryKindsType, number>>;
-};
+import "../routing-qc0V00-j.js";
+import { _ as SearchableAttributesChat, a as IndexProperty, c as QueryKindsType, d as ResultType, f as RoutableJsonNode, g as SearchableAttributes, h as SearchSettings, i as IndexModel, l as ResultData, m as SearchParams, n as IndexEntry, o as IndexResource, p as SearchAttributeNames, r as IndexMethod, s as QueryKinds, t as GuideResultType, u as ResultRecordType } from "../types-CTBDtD34.js";
+export { GuideResultType, IndexEntry, IndexMethod, IndexModel, IndexProperty, IndexResource, QueryKinds, QueryKindsType, ResultData, ResultRecordType, ResultType, RoutableJsonNode, SearchAttributeNames, SearchParams, SearchSettings, SearchableAttributes, SearchableAttributesChat };

package/dist/search/types.js

@@ -1,24 +1,3 @@
-export const QueryKinds = ['all', 'resource', 'http_method', 'model', 'property', 'guide'];
-export const SearchableAttributes = [
-    'name',
-    'title',
-    'ident',
-    'Name',
-    'qualified',
-    'QualifiedName',
-    'endpoint',
-    'summary',
-    'description',
-    'docstring',
-];
-export const SearchableAttributesChat = [
-    'title',
-    'name',
-    'endpoint',
-    'summary',
-    'description',
-    'qualified',
-    'ident',
-    'content',
-];
-//# sourceMappingURL=types.js.map
+import { n as SearchableAttributes, r as SearchableAttributesChat, t as QueryKinds } from "../types-DFN4M1Sp.js";
+
+export { QueryKinds, SearchableAttributes, SearchableAttributesChat };

package/dist/search-B6loAGmB.d.ts

@@ -0,0 +1,21 @@
+import { d as ResultType, h as SearchSettings, m as SearchParams } from "./types-CTBDtD34.js";
+import * as React$1 from "react";
+import * as react_jsx_runtime63 from "react/jsx-runtime";
+
+//#region src/contexts/search.d.ts
+type SearchContextType = {
+  settings: SearchSettings;
+  onSelect?: (stainlessPath: string) => void;
+  pageFind?: string;
+};
+declare function useSearchContext(): SearchContextType;
+declare function useSearch(): (params: SearchParams) => Promise<ResultType | undefined>;
+type SearchProviderProps = SearchContextType & {
+  children: React$1.ReactNode;
+};
+declare function SearchProvider({
+  children,
+  ...props
+}: SearchProviderProps): react_jsx_runtime63.JSX.Element;
+//#endregion
+export { useSearchContext as a, useSearch as i, SearchProvider as n, SearchProviderProps as r, SearchContextType as t };

package/dist/sidebar-C8KirYjg.d.ts

@@ -0,0 +1,35 @@
+import * as React$1 from "react";
+import * as react_jsx_runtime53 from "react/jsx-runtime";
+
+//#region src/components/sidebar.d.ts
+type SidebarExpanderProps = {
+  open?: boolean;
+  summary: React$1.ReactNode;
+  children?: React$1.ReactNode;
+};
+declare function SidebarExpander({
+  open,
+  summary,
+  children
+}: SidebarExpanderProps): react_jsx_runtime53.JSX.Element;
+type SidebarMethodProps = {
+  method: SDKJSON.Method;
+};
+declare function SidebarMethod({
+  method
+}: SidebarMethodProps): react_jsx_runtime53.JSX.Element;
+type SidebarResourceProps = {
+  resource: SDKJSON.Resource;
+};
+declare function SidebarResource({
+  resource
+}: SidebarResourceProps): react_jsx_runtime53.JSX.Element;
+type SidebarProps = {
+  resources: SDKJSON.Resource[];
+  selectedPath?: string;
+};
+declare function Sidebar({
+  resources
+}: SidebarProps): react_jsx_runtime53.JSX.Element;
+//#endregion
+export { SidebarProps as a, SidebarMethodProps as i, SidebarExpander as n, SidebarResource as o, SidebarMethod as r, SidebarResourceProps as s, Sidebar as t };

package/dist/snippets-EUzM4fRO.d.ts

@@ -0,0 +1,45 @@
+import { C as TransformRequestSnippetFn } from "./sdk-Zg3Rggk3.js";
+import * as React$1 from "react";
+import * as react_jsx_runtime16 from "react/jsx-runtime";
+
+//#region src/components/snippets.d.ts
+type SnippetCodeProps = {
+  content: string;
+  signature?: string;
+  language?: string;
+};
+declare function SnippetCode({
+  content,
+  language
+}: SnippetCodeProps): react_jsx_runtime16.JSX.Element;
+type SnippetProps = {
+  method: SDKJSON.Method;
+  requestTitle?: React$1.ReactNode;
+  transformRequestSnippet?: TransformRequestSnippetFn;
+};
+type SnippetContainerProps = {
+  children: React$1.ReactNode;
+  signature?: string;
+};
+declare function SnippetContainer({
+  children
+}: SnippetContainerProps): react_jsx_runtime16.JSX.Element;
+type SnippetRequestContainerProps = {
+  children?: React$1.ReactNode;
+  signature?: string;
+};
+declare function SnippetRequestContainer({
+  children
+}: SnippetRequestContainerProps): react_jsx_runtime16.JSX.Element;
+declare function Snippet({
+  requestTitle,
+  method,
+  transformRequestSnippet
+}: SnippetProps): react_jsx_runtime16.JSX.Element;
+declare function SnippetResponse({
+  responses
+}: {
+  responses: SDKJSON.Method['exampleResponses'];
+}): react_jsx_runtime16.JSX.Element | null;
+//#endregion
+export { SnippetContainerProps as a, SnippetRequestContainerProps as c, SnippetContainer as i, SnippetResponse as l, SnippetCode as n, SnippetProps as o, SnippetCodeProps as r, SnippetRequestContainer as s, Snippet as t };

package/dist/style-pN9hCoec.d.ts

@@ -0,0 +1,181 @@
+//#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 SnippetResponseTitle: "stldocs-snippet-response-title";
+  readonly SnippetResponseClosed: "stldocs-snippet-response-closed";
+  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 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 Chat: "stldocs-chat";
+  readonly ChatHeader: "stldocs-chat-header";
+  readonly ChatInput: "stldocs-chat-input";
+  readonly ChatInputButtons: "stldocs-chat-input-buttons";
+  readonly ChatMessages: "stldocs-chat-messages";
+  readonly ChatMessage: "stldocs-chat-message";
+  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";
+  readonly Dropdown: "stldocs-dropdown";
+  readonly DropdownTrigger: "stldocs-dropdown-trigger";
+  readonly DropdownTriggerContent: "stldocs-dropdown-trigger-content";
+  readonly DropdownChevron: "stldocs-dropdown-chevron";
+  readonly DropdownMenu: "stldocs-dropdown-menu";
+  readonly DropdownItem: "stldocs-dropdown-item";
+  readonly DropdownItemLink: "stldocs-dropdown-item-link";
+  readonly Button: "stldocs-button";
+  readonly ButtonSecondary: "stldocs-button-secondary";
+  readonly ButtonIcon: "stldocs-button-icon";
+};
+//#endregion
+export { _default as t };