@stainless-api/docs-ui 0.1.0-beta.72 → 0.1.0-beta.74

package/dist/routing.js

@@ -1,3 +1,205 @@
-import { _ as updateHistory, a as findNavigationPath, c as generateRouteList, d as isSupportedLanguage, f as parseRoute, g as trimStainlessPath, h as scrollToPath, i as expandToElement, l as getLanguageSnippet, n as Languages, o as generateMissingRouteList, p as parseStainlessPath, r as SupportedLanguageSyntaxes, s as generateRoute, t as LanguageNames, u as getResource, v as walkTree } from "./routing-C64k4fmX.js";
+import { t as __exportAll } from "./chunk-BYypO7fO.js";
 
-export { LanguageNames, Languages, SupportedLanguageSyntaxes, expandToElement, findNavigationPath, generateMissingRouteList, generateRoute, generateRouteList, getLanguageSnippet, getResource, isSupportedLanguage, parseRoute, parseStainlessPath, scrollToPath, trimStainlessPath, updateHistory, walkTree };
+//#region src/routing.ts
+var routing_exports = /* @__PURE__ */ __exportAll({
+	LanguageNames: () => LanguageNames,
+	Languages: () => Languages,
+	SupportedLanguageSyntaxes: () => SupportedLanguageSyntaxes,
+	expandToElement: () => expandToElement,
+	findNavigationPath: () => findNavigationPath,
+	generateMissingRouteList: () => generateMissingRouteList,
+	generateRoute: () => generateRoute,
+	generateRouteList: () => generateRouteList,
+	getLanguageSnippet: () => getLanguageSnippet,
+	getResource: () => getResource,
+	isSupportedLanguage: () => isSupportedLanguage,
+	parseRoute: () => parseRoute,
+	parseStainlessPath: () => parseStainlessPath,
+	scrollToPath: () => scrollToPath,
+	trimStainlessPath: () => trimStainlessPath,
+	updateHistory: () => updateHistory,
+	walkTree: () => walkTree
+});
+const Languages = [
+	"http",
+	"node",
+	"python",
+	"go",
+	"typescript",
+	"terraform",
+	"ruby",
+	"java",
+	"kotlin",
+	"csharp",
+	"php",
+	"cli"
+];
+const SupportedLanguageSyntaxes = [
+	"http",
+	"javascript",
+	"python",
+	"go",
+	"typescript",
+	"terraform",
+	"ruby",
+	"java",
+	"kotlin",
+	"csharp",
+	"bash"
+];
+const LanguageNames = {
+	http: "HTTP",
+	node: "TypeScript",
+	typescript: "TypeScript",
+	python: "Python",
+	go: "Go",
+	ruby: "Ruby",
+	java: "Java",
+	kotlin: "Kotlin",
+	terraform: "Terraform",
+	csharp: "C#",
+	php: "PHP",
+	cli: "CLI Tool"
+};
+function getLanguageSnippet(language) {
+	return language === "http" ? "http.curl" : `${language}.default`;
+}
+function isSupportedLanguage(language) {
+	return Languages.includes(language);
+}
+const DefaultLanguage = "http";
+const StainlessPathPattern = /(\(resource\) (?<resource>[^\s]+))( > (\(method\) (?<method>[^\s]+)|\(model\) (?<model>[^\s]+))?)?/;
+function parseStainlessPath(stainlessPath) {
+	const match = stainlessPath.match(StainlessPathPattern);
+	if (!match?.groups) return null;
+	return {
+		resource: match.groups.resource?.split(".") ?? null,
+		method: match.groups.method ?? null,
+		model: match.groups.model ?? null,
+		routable: match.groups.model ? match[1] : match[0]
+	};
+}
+function trimStainlessPath(stainlessPath) {
+	return stainlessPath.replace(/ > \([^\s]+\)$/, "");
+}
+function getResource(stainlessPath) {
+	return parseStainlessPath(stainlessPath)?.resource?.[0];
+}
+function parseRoute(basePath, route) {
+	if (!route.startsWith(basePath)) return {
+		stainlessPath: "",
+		language: DefaultLanguage
+	};
+	if (basePath && route.startsWith(basePath)) route = route.slice(basePath.length);
+	let stainlessPath = "";
+	let elements = route.slice(1).split("/");
+	let language = DefaultLanguage;
+	if (elements[0] && Languages.includes(elements[0])) {
+		language = elements[0];
+		elements = elements.slice(1);
+	}
+	while (elements.length > 0) switch (elements.shift()) {
+		case "resources":
+			stainlessPath += `(resource) ${elements.shift()}`;
+			break;
+		case "subresources":
+			stainlessPath += `.${elements.shift()}`;
+			break;
+		case "methods":
+			stainlessPath += ` > (method) ${elements.shift()}`;
+			break;
+	}
+	return {
+		stainlessPath,
+		language
+	};
+}
+function generateRoute(basePath, language, stainlessPath) {
+	const parsedPath = parseStainlessPath(stainlessPath);
+	if (!parsedPath) return null;
+	const path = [basePath.endsWith("/") ? basePath.slice(0, -1) : basePath];
+	if (language && language !== DefaultLanguage) path.push(language);
+	const resources = parsedPath.resource.flatMap((name, index) => [index > 0 ? "subresources" : "resources", name]);
+	const resourcePath = parsedPath.model ? resources.slice(0, 2) : resources;
+	path.push(...resourcePath);
+	if (parsedPath.method) path.push("methods", parsedPath.method);
+	return stainlessPath.length > parsedPath.routable.length ? `${path.join("/")}#${encodeURIComponent(stainlessPath)}` : path.join("/");
+}
+function* walkResource(resource, path, includeModels) {
+	yield {
+		data: resource,
+		path
+	};
+	for (const data of Object.values(resource.methods)) yield {
+		data,
+		path: [
+			...path,
+			"methods",
+			data.name
+		]
+	};
+	if (includeModels) for (const data of Object.values(resource.models)) yield {
+		data,
+		path: [
+			...path,
+			"models",
+			data.name
+		]
+	};
+	for (const data of Object.values(resource.subresources ?? {})) yield* walkResource(data, [
+		...path,
+		"subresources",
+		data.name
+	]);
+}
+function* walkTree(spec, includeModels) {
+	for (const data of Object.values(spec.resources)) yield* walkResource(data, ["resources", data.name], includeModels);
+}
+function generateRouteList({ spec, languages, excludeLanguages = [] }) {
+	const entries = Array.from(walkTree(spec));
+	return (languages ?? spec.docs?.languages ?? ["http"]).filter((lang) => Languages.includes(lang)).filter((lang) => !excludeLanguages?.includes(lang)).flatMap((language) => entries.map(({ path, data: { title, kind, stainlessPath } }) => ({
+		title,
+		kind,
+		language,
+		stainlessPath,
+		slug: (language === "http" ? path : [language, ...path]).join("/")
+	})));
+}
+function generateMissingRouteList({ spec, basePath }) {
+	const entries = Array.from(walkTree(spec));
+	return (spec.docs?.languages ?? ["http"]).filter((lang) => Languages.includes(lang)).flatMap((language) => entries.filter(({ data: { stainlessPath, ...rest } }) => {
+		if (spec.decls?.[language]?.[stainlessPath] === void 0) return rest.kind === "http_method";
+		return false;
+	}).map(({ path }) => `${basePath.endsWith("/") ? basePath.slice(0, -1) : basePath}/${language === "http" ? path.join("/") : [language, ...path].join("/")}`));
+}
+function findNavigationPath(items, target) {
+	for (const item of Object.values(items)) {
+		if (item.stainlessPath === target) return [item.stainlessPath];
+		if (item.kind === "http_method") continue;
+		const path = findNavigationPath([...Object.values(item.methods ?? {}), ...Object.values(item.subresources ?? {})], target);
+		if (path) return [item.stainlessPath, ...path];
+	}
+}
+function expandToElement(el) {
+	while (el) {
+		if (el instanceof HTMLDetailsElement) el.open = true;
+		el = el.parentElement;
+	}
+}
+function scrollToPath(stainlessPath) {
+	const el = document.getElementById(stainlessPath);
+	if (el) {
+		expandToElement(el);
+		el.scrollIntoView({ behavior: "smooth" });
+	}
+}
+function updateHistory(basePath, language, stainlessPath) {
+	const path = generateRoute(basePath, language, stainlessPath);
+	window.history.pushState({
+		stainlessPath,
+		language
+	}, "", path);
+}
+
+//#endregion
+export { LanguageNames, Languages, SupportedLanguageSyntaxes, expandToElement, findNavigationPath, generateMissingRouteList, generateRoute, generateRouteList, getLanguageSnippet, getResource, isSupportedLanguage, parseRoute, parseStainlessPath, scrollToPath, routing_exports as t, trimStainlessPath, updateHistory, walkTree };

package/dist/spec.d.ts

@@ -1,5 +1,5 @@
-import { _ as Spec, d as Method, f as Model, i as DeclarationNode, m as Resource, v as SpecLanguage } from "./index-W4Td2Hl7.js";
-import { t as DocsLanguage } from "./routing-pAL4V4hv.js";
+import { _ as Spec, d as Method, f as Model, i as DeclarationNode, m as Resource, v as SpecLanguage } from "./index-PdnFhQF9.js";
+import { DocsLanguage } from "./routing.js";
 
 //#region src/spec.d.ts
 type SecurityScheme = Spec['security_schemes'][number];
@@ -36,13 +36,13 @@ declare function generateNavigation(resource: Partial<Resource>): {
 declare function generateSpecForResource(spec: Spec, name: string, lang: DocsLanguage, transforms: SpecTransforms): Partial<Spec>;
 declare function transform(spec: Spec, transforms: SpecTransforms): {
   name: string;
-  lang: "http" | "node" | "python" | "go" | "typescript" | "terraform" | "ruby" | "java" | "kotlin" | "csharp" | "php" | "cli";
+  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: ("http" | "node" | "python" | "go" | "typescript" | "terraform" | "ruby" | "java" | "kotlin")[] | undefined;
+    languages: ("cli" | "csharp" | "go" | "http" | "java" | "kotlin" | "node" | "php" | "python" | "ruby" | "terraform" | "typescript" | "sql" | "openapi")[] | undefined;
     resources: {
       [k: string]: {
         title: string | undefined;

package/dist/spec.js

@@ -1,5 +1,5 @@
-import { n as Languages } from "./routing-C64k4fmX.js";
-import { i as isResourceEmpty } from "./utils-DPbkW1Tz.js";
+import { Languages } from "./routing.js";
+import { isResourceEmpty } from "./utils.js";
 
 //#region src/spec.ts
 const defaultTransforms = {

package/dist/style.js

@@ -1,3 +1,178 @@
-import { t as style_default } from "./style-DJIYkFhO.js";
+//#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",
+	SnippetMulti: "stldocs-snippet-multi",
+	SnippetMultiTabs: "stldocs-snippet-multi-tabs",
+	SnippetMultiTab: "stldocs-snippet-multi-tab",
+	SnippetMultiContent: "stldocs-snippet-multi-content",
+	SnippetMultiPane: "stldocs-snippet-multi-pane",
+	SnippetMultiPaneActive: "stldocs-snippet-multi-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",
+	MethodAvailableLanguages: "stldocs-method-available-languages",
+	SignatureTitle: "stldocs-signature-title",
+	SignatureName: "stldocs-signature-name",
+	SignatureQualified: "stldocs-signature-qualified",
+	SignatureParams: "stldoc-signature-params",
+	SignatureParen: "stldocs-signature-paren",
+	SignatureReturns: "stldocs-signature-returns",
+	TerraformResourceTitle: "stldocs-terraform-resource-title",
+	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",
+	SidebarList: "stldocs-sidebar-list",
+	SidebarExpander: "stldocs-sidebar-expander",
+	SidebarExpanderSummary: "stldocs-sidebar-expander-summary",
+	SidebarExpanderContent: "stldocs-sidebar-expander-content",
+	SidebarEntry: "stldocs-sidebar-entry",
+	SidebarEntryLink: "stldocs-sidebar-entry-link",
+	SidebarEntryGroup: "stldocs-sidebar-entry-group",
+	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 default };

package/dist/use-strict-context-L0c8JKg4.js

@@ -0,0 +1,16 @@
+import React from "react";
+
+//#region src/hooks/use-strict-context.tsx
+function createStrictContext(displayName) {
+	const Context = React.createContext(null);
+	Context.displayName = displayName;
+	function useStrictContext() {
+		const context = React.useContext(Context);
+		if (context === null) throw new Error(`use${displayName} must be used within a ${displayName}Provider`);
+		return context;
+	}
+	return [Context.Provider, useStrictContext];
+}
+
+//#endregion
+export { createStrictContext as t };

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { _ as Spec, c as ID, m as Resource, s as HttpAST } from "./index-W4Td2Hl7.js";
+import { _ as Spec, c as ID, m as Resource, s as HttpAST } from "./index-PdnFhQF9.js";
 
 //#region src/utils.d.ts
 declare namespace utils_d_exports {

package/dist/utils.js

@@ -1,3 +1,54 @@
-import { i as isResourceEmpty, n as getBodyParams, r as getResourceFromSpec, t as flatResources } from "./utils-DPbkW1Tz.js";
+import { t as __exportAll } from "./chunk-BYypO7fO.js";
+import { parseStainlessPath } from "./routing.js";
 
-export { flatResources, getBodyParams, getResourceFromSpec, isResourceEmpty };
+//#region src/utils.ts
+var utils_exports = /* @__PURE__ */ __exportAll({
+	flatResources: () => flatResources,
+	getBodyParams: () => getBodyParams,
+	getResourceFromSpec: () => getResourceFromSpec,
+	isResourceEmpty: () => isResourceEmpty
+});
+function flatResources(resources, parents) {
+	return Object.keys(resources ?? {}).flatMap((key) => {
+		const resource = resources[key];
+		return [{
+			resource,
+			parents
+		}, ...resource.subresources ? flatResources(resource.subresources, [...parents, resource]) : []];
+	});
+}
+function getResourceFromSpec(stainlessPath, spec) {
+	if (typeof stainlessPath === "string") {
+		const parsed = parseStainlessPath(stainlessPath);
+		if (!parsed?.resource) return null;
+		stainlessPath = parsed.resource;
+	}
+	return stainlessPath.slice(1).reduce((acc, cur) => acc?.subresources?.[cur], spec.resources[stainlessPath[0]]) ?? null;
+}
+function isResourceEmpty(resource) {
+	return !(Object.values(resource.methods).length > 0 || Object.values(resource.models).length > 0 || Object.values(resource.subresources).length > 0);
+}
+function getBodyParams(decl) {
+	if (!decl.bodyParamsChildren) return null;
+	const keys = Object.keys(decl.bodyParamsChildren);
+	if (keys.length > 1) console.warn("multiple bodyParams content types in " + decl.stainlessPath + ":", keys);
+	const jsonKey = keys.find((e) => /[/+]json(;|$)/.test(e));
+	if (jsonKey) return {
+		params: decl.bodyParamsChildren[jsonKey],
+		encoding: "json"
+	};
+	const formDataKey = keys.find((e) => /^multipart\/form-data(;|$)/.test(e));
+	if (formDataKey) return {
+		params: decl.bodyParamsChildren[formDataKey],
+		encoding: "form-data"
+	};
+	const firstKey = keys[0];
+	if (firstKey) return {
+		params: decl.bodyParamsChildren[firstKey],
+		encoding: "unknown"
+	};
+	return null;
+}
+
+//#endregion
+export { flatResources, getBodyParams, getResourceFromSpec, isResourceEmpty, utils_exports as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stainless-api/docs-ui",
   "private": false,
-  "version": "0.1.0-beta.72",
+  "version": "0.1.0-beta.74",
   "publishConfig": {
     "access": "public"
   },
@@ -27,10 +27,10 @@
     "dotenv": "17.2.3",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "tsdown": "^0.20.0",
+    "tsdown": "^0.20.3",
     "typescript": "5.9.3",
     "@stainless/eslint-config": "0.1.0-beta.1",
-    "@stainless/sdk-json": "^0.1.0-beta.5"
+    "@stainless/sdk-json": "^0.1.0-beta.6"
   },
   "exports": {
     ".": {

package/dist/breadcrumbs-46Qjx1Pd.d.ts

@@ -1,25 +0,0 @@
-import { _ as Spec } from "./index-W4Td2Hl7.js";
-import * as react_jsx_runtime1 from "react/jsx-runtime";
-
-//#region src/components/breadcrumbs.d.ts
-type Breadcrumb = {
-  title: string;
-  href: string;
-};
-type BreadcrumbConfig = {
-  includeCurrentPage?: boolean;
-};
-declare function generateApiBreadcrumbs(fullPath: string, spec: any, basePath: string): Breadcrumb[] | null;
-declare function SDKBreadcrumbs({
-  spec,
-  currentPath,
-  basePath,
-  config
-}: {
-  spec: Spec;
-  currentPath: string;
-  basePath?: string;
-  config?: BreadcrumbConfig | null;
-}): react_jsx_runtime1.JSX.Element | null;
-//#endregion
-export { generateApiBreadcrumbs as n, SDKBreadcrumbs as t };

package/dist/breadcrumbs-BZ4wBC9-.d.ts

@@ -1,25 +0,0 @@
-import { _ as Spec } from "./index-W4Td2Hl7.js";
-import * as react_jsx_runtime13 from "react/jsx-runtime";
-
-//#region src/components/breadcrumbs.d.ts
-type Breadcrumb = {
-  title: string;
-  href: string;
-};
-type BreadcrumbConfig = {
-  includeCurrentPage?: boolean;
-};
-declare function generateApiBreadcrumbs(fullPath: string, spec: any, basePath: string): Breadcrumb[] | null;
-declare function SDKBreadcrumbs({
-  spec,
-  currentPath,
-  basePath,
-  config
-}: {
-  spec: Spec;
-  currentPath: string;
-  basePath?: string;
-  config?: BreadcrumbConfig | null;
-}): react_jsx_runtime13.JSX.Element | null;
-//#endregion
-export { generateApiBreadcrumbs as n, SDKBreadcrumbs as t };

package/dist/breadcrumbs-BiBfNqBI.js

@@ -1,63 +0,0 @@
-import { t as style_default } from "./style-DJIYkFhO.js";
-import { n as Languages } from "./routing-C64k4fmX.js";
-import { i as Join } from "./primitives-CNG-fEhQ.js";
-import { jsx } from "react/jsx-runtime";
-import { ChevronRight } from "lucide-react";
-
-//#region src/components/breadcrumbs.tsx
-function generateApiBreadcrumbs(fullPath, spec, basePath) {
-	const cleanBasePath = basePath.replace(/\/+$/, "");
-	const cleanPath = fullPath.replace(/\/+$/, "");
-	if (!cleanPath.startsWith(cleanBasePath)) return null;
-	const rest = cleanPath.slice(cleanBasePath.length).split("/").filter(Boolean);
-	const breadcrumbs = [];
-	let href = cleanBasePath;
-	let i = 0;
-	if (Languages.includes(rest[0])) {
-		href += `/${rest[0]}`;
-		i++;
-	}
-	breadcrumbs.push({
-		title: "API Reference",
-		href
-	});
-	let currentSpec = spec;
-	while (i < rest.length) {
-		const idType = rest[i];
-		const idValue = rest[i + 1];
-		if (!idType || !idValue || !currentSpec?.[idType]?.[idValue]) break;
-		currentSpec = currentSpec[idType][idValue];
-		href += `/${idType}/${idValue}`;
-		const title = (idType === "methods" ? currentSpec.summary : currentSpec.title) ?? idValue;
-		breadcrumbs.push({
-			title,
-			href
-		});
-		i += 2;
-	}
-	return breadcrumbs;
-}
-function SDKBreadcrumbs({ spec, currentPath, basePath = "/api", config = { includeCurrentPage: false } }) {
-	const breadcrumbs = generateApiBreadcrumbs(currentPath, spec, basePath);
-	if (!breadcrumbs || breadcrumbs.length === 0) return null;
-	if (!config?.includeCurrentPage && breadcrumbs.length > 1) breadcrumbs.pop();
-	const items = breadcrumbs.map((crumb, index) => /* @__PURE__ */ jsx("div", {
-		className: style_default.BreadcrumbsItem,
-		children: /* @__PURE__ */ jsx("a", {
-			href: crumb.href,
-			className: style_default.BreadcrumbsLink,
-			children: crumb.title
-		})
-	}, index));
-	return /* @__PURE__ */ jsx("div", {
-		className: style_default.Breadcrumbs,
-		children: /* @__PURE__ */ jsx(Join, {
-			limit: breadcrumbs.length,
-			items,
-			children: /* @__PURE__ */ jsx(ChevronRight, {})
-		})
-	});
-}
-
-//#endregion
-export { generateApiBreadcrumbs as n, SDKBreadcrumbs as t };