@stainless-api/docs-ui 0.1.0-beta.8 → 0.1.0-beta.80

package/dist/markdown/printer.js

@@ -0,0 +1,76 @@
+import { t as __exportAll } from "../chunk-BYypO7fO.js";
+import { DocsProvider } from "../contexts/docs.js";
+import "../use-strict-context-L0c8JKg4.js";
+import { useLanguageComponents } from "../contexts/index.js";
+import style_default from "../style.js";
+import { ComponentProvider } from "../contexts/component.js";
+import "react";
+import { jsx } from "react/jsx-runtime";
+import { renderToStaticMarkup } from "react-dom/server";
+
+//#region src/markdown/printer.tsx
+var printer_exports = /* @__PURE__ */ __exportAll({
+	declaration: () => declaration,
+	methodSignature: () => methodSignature,
+	type: () => type,
+	typeName: () => typeName
+});
+function SDKReference({ stainlessPath, children }) {
+	if (!stainlessPath) return children;
+	return /* @__PURE__ */ jsx("span", {
+		className: style_default.TypeReference,
+		children
+	});
+}
+function Providers({ language, children }) {
+	return /* @__PURE__ */ jsx(DocsProvider, {
+		spec: null,
+		language,
+		children: /* @__PURE__ */ jsx(ComponentProvider, {
+			components: { SDKReference },
+			children
+		})
+	});
+}
+function RenderType({ type, full }) {
+	const { Type, TypeName } = useLanguageComponents();
+	return full ? /* @__PURE__ */ jsx(Type, { type }) : /* @__PURE__ */ jsx(TypeName, { type });
+}
+function typeName(language, type) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderType, { type })
+	}));
+}
+function type(language, type) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderType, {
+			type,
+			full: true
+		})
+	}));
+}
+function RenderDeclaration({ decl }) {
+	const { Declaration } = useLanguageComponents();
+	return /* @__PURE__ */ jsx(Declaration, { decl });
+}
+function declaration(language, decl) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderDeclaration, { decl })
+	}));
+}
+function RenderMethod({ method }) {
+	const { MethodSignature } = useLanguageComponents();
+	return /* @__PURE__ */ jsx(MethodSignature, { decl: method });
+}
+function methodSignature(language, decl) {
+	return renderToStaticMarkup(/* @__PURE__ */ jsx(Providers, {
+		language,
+		children: /* @__PURE__ */ jsx(RenderMethod, { method: decl })
+	}));
+}
+
+//#endregion
+export { declaration, methodSignature, printer_exports as t, type, typeName };

package/dist/markdown/utils.d.ts

@@ -0,0 +1,21 @@
+import { u as LanguageDeclNodes, v as Spec, y as SpecLanguage } from "../index-pvh-w1xa.js";
+import { DocsLanguage } from "../routing.js";
+import { TransformRequestSnippetFn } from "../components/sdk.js";
+
+//#region src/markdown/utils.d.ts
+type EnvironmentType = {
+  spec: Spec;
+  language: DocsLanguage;
+  transforms?: {
+    transformRequestSnippet?: TransformRequestSnippetFn;
+  };
+  options: {
+    renderNestedResources?: boolean;
+    includeModelProperties?: boolean | 'method-page';
+  };
+};
+declare function getDecl(env: EnvironmentType, path: string): LanguageDeclNodes[SpecLanguage] | undefined;
+declare function getSnippet(env: EnvironmentType, path: string, snippetId?: 'default' | `custom:${string}`): string | undefined;
+declare function stripMarkup(content: string): string;
+//#endregion
+export { EnvironmentType, getDecl, getSnippet, stripMarkup };

package/dist/markdown/utils.js

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

package/dist/routing.d.ts

@@ -0,0 +1,61 @@
+import { d as Method, f as Model, h as Resource, v as Spec } from "./index-pvh-w1xa.js";
+
+//#region src/routing.d.ts
+declare namespace routing_d_exports {
+  export { DocsLanguage, LanguageNames, Languages, ParsedStainlessPath, RouteEntry, SpecTreeEntry, SupportedLanguageSyntaxes, expandToElement, findNavigationPath, generateMissingRouteList, generateRoute, generateRouteList, getLanguageSnippet, getResource, isSupportedLanguage, parseRoute, parseStainlessPath, scrollToPath, trimStainlessPath, updateHistory, walkTree };
+}
+declare const Languages: readonly ["http", "node", "python", "go", "typescript", "terraform", "ruby", "java", "kotlin", "csharp", "php", "cli"];
+declare const SupportedLanguageSyntaxes: string[];
+type DocsLanguage = (typeof Languages)[number];
+declare const LanguageNames: Record<DocsLanguage, string>;
+declare function getLanguageSnippet(language: DocsLanguage): "http.curl" | "node.default" | "python.default" | "go.default" | "typescript.default" | "terraform.default" | "ruby.default" | "java.default" | "kotlin.default" | "csharp.default" | "php.default" | "cli.default";
+declare function isSupportedLanguage(language: string): language is DocsLanguage;
+type ParsedStainlessPath = ReturnType<typeof parseStainlessPath>;
+declare function parseStainlessPath(stainlessPath: string): {
+  resource: string[] | null;
+  method: string | null;
+  model: string | null;
+  routable: string | undefined;
+} | null;
+declare function trimStainlessPath(stainlessPath: string): string;
+declare function getResource(stainlessPath: string): string | undefined;
+declare function parseRoute(basePath: string, route: string): {
+  stainlessPath: string;
+  language: DocsLanguage;
+};
+declare function generateRoute(basePath: string, language: string, stainlessPath: string): string | null;
+type SpecTreeEntry = {
+  data: Method | Resource | Model;
+  path: string[];
+};
+declare function walkTree(spec: Spec, includeModels?: boolean): Generator<SpecTreeEntry, void, any>;
+type RouteEntry = {
+  title: string;
+  kind: SpecTreeEntry['data']['kind'];
+  language: DocsLanguage;
+  stainlessPath: string;
+  slug: string;
+};
+declare function generateRouteList({
+  spec,
+  languages,
+  excludeLanguages
+}: {
+  spec: Spec;
+  languages?: DocsLanguage[];
+  excludeLanguages?: DocsLanguage[];
+}): RouteEntry[];
+declare function generateMissingRouteList({
+  spec,
+  basePath
+}: {
+  spec: Spec;
+  basePath: string;
+}): string[];
+type ResourceOrMethod = Resource | Method;
+declare function findNavigationPath(items: ResourceOrMethod[], target: string): string[] | undefined;
+declare function expandToElement(el: HTMLElement | null): void;
+declare function scrollToPath(stainlessPath: string): void;
+declare function updateHistory(basePath: string, language: DocsLanguage, stainlessPath: string): void;
+//#endregion
+export { DocsLanguage, LanguageNames, Languages, ParsedStainlessPath, RouteEntry, SpecTreeEntry, SupportedLanguageSyntaxes, expandToElement, findNavigationPath, generateMissingRouteList, generateRoute, generateRouteList, getLanguageSnippet, getResource, isSupportedLanguage, parseRoute, parseStainlessPath, scrollToPath, routing_d_exports as t, trimStainlessPath, updateHistory, walkTree };

package/dist/routing.js

@@ -1,180 +1,206 @@
-// src/routing.ts
-var Languages = [
-  "http",
-  "node",
-  "python",
-  "go",
-  "typescript",
-  "terraform",
-  "ruby",
-  "java",
-  "kotlin"
+import { t as __exportAll } from "./chunk-BYypO7fO.js";
+
+//#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"
 ];
-var SupportedLanguageSyntaxes = [
-  "http",
-  "javascript",
-  "python",
-  "go",
-  "typescript",
-  "terraform",
-  "ruby",
-  "java",
-  "kotlin"
+const SupportedLanguageSyntaxes = [
+	"http",
+	"javascript",
+	"python",
+	"go",
+	"typescript",
+	"terraform",
+	"ruby",
+	"java",
+	"kotlin",
+	"csharp",
+	"php",
+	"bash"
 ];
-var LanguageNames = {
-  http: "HTTP",
-  node: "TypeScript",
-  typescript: "TypeScript",
-  python: "Python",
-  go: "Go",
-  ruby: "Ruby",
-  java: "Java",
-  kotlin: "Kotlin",
-  terraform: "Terraform"
+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`;
+	return language === "http" ? "http.curl" : `${language}.default`;
 }
 function isSupportedLanguage(language) {
-  return Languages.includes(language);
+	return Languages.includes(language);
 }
-var DefaultLanguage = "http";
-var StainlessPathPattern = /(\(resource\) (?<resource>[^\s]+))( > (\(method\) (?<method>[^\s]+)|\(model\) (?<model>[^\s]+))?)?/;
+const DefaultLanguage = "http";
+const StainlessPathPattern = /(\(resource\) (?<resource>[^\s]+))( > (\(method\) (?<method>[^\s]+)|\(model\) (?<model>[^\s]+))?)?/;
 function parseStainlessPath(stainlessPath) {
-  const match = stainlessPath.match(StainlessPathPattern);
-  if (!match) return null;
-  return {
-    resource: match.groups.resource.split("."),
-    method: match.groups.method ?? null,
-    model: match.groups.model ?? null,
-    routable: match.groups.model ? match[1] : match[0]
-  };
+	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]+\)$/, "");
+	return stainlessPath.replace(/ > \([^\s]+\)$/, "");
 }
 function getResource(stainlessPath) {
-  const parsed = parseStainlessPath(stainlessPath);
-  return parsed?.resource[0];
+	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) {
-    const element = elements.shift();
-    switch (element) {
-      case "resources":
-        stainlessPath += `(resource) ${elements.shift()}`;
-        break;
-      case "subresources":
-        stainlessPath += `.${elements.shift()}`;
-        break;
-      case "methods":
-        stainlessPath += ` > (method) ${elements.shift()}`;
-        break;
-    }
-  }
-  return { stainlessPath, language };
+	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("/");
+	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]);
-  }
+	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);
-  }
+	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));
-  const langs = languages ?? spec.docs?.languages ?? ["http"];
-  return langs.filter((lang) => Languages.includes(lang) && lang !== "terraform").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 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];
-  }
+	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.tagName === "DETAILS") el["open"] = true;
-    el = el.parentElement;
-  }
+	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" });
-  }
+	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);
+	const path = generateRoute(basePath, language, stainlessPath);
+	window.history.pushState({
+		stainlessPath,
+		language
+	}, "", path);
 }
-export {
-  LanguageNames,
-  Languages,
-  SupportedLanguageSyntaxes,
-  expandToElement,
-  findNavigationPath,
-  generateRoute,
-  generateRouteList,
-  getLanguageSnippet,
-  getResource,
-  isSupportedLanguage,
-  parseRoute,
-  parseStainlessPath,
-  scrollToPath,
-  trimStainlessPath,
-  updateHistory,
-  walkTree
-};
+
+//#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

@@ -0,0 +1,65 @@
+import { d as Method, f as Model, h as Resource, i as DeclarationNode, v as Spec, y as SpecLanguage } from "./index-pvh-w1xa.js";
+import { DocsLanguage } from "./routing.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: "http" | "node" | "python" | "go" | "typescript" | "terraform" | "ruby" | "java" | "kotlin" | "csharp" | "php" | "cli";
+  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" | "csharp" | "php" | "cli" | "sql" | "openapi")[] | 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 };