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

package/dist/languages/typescript.d.ts

@@ -0,0 +1,40 @@
+import { b as TSAST } from "../index-pvh-w1xa.js";
+import { PropertyFn } from "./index.js";
+import * as React$1 from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/languages/typescript.d.ts
+declare namespace typescript_d_exports {
+  export { Declaration, DeclarationProps, MethodSignature, MethodSignatureProps, Property, PropertyProps, Type, TypeName };
+}
+type TypeProps = {
+  type: TSAST.TSType;
+};
+declare function TypeName({
+  type
+}: TypeProps): string | react_jsx_runtime0.JSX.Element;
+declare function Type({
+  type
+}: TypeProps): react_jsx_runtime0.JSX.Element;
+type MethodSignatureProps = {
+  decl: TSAST.TSDeclFunction;
+};
+declare function MethodSignature({
+  decl
+}: MethodSignatureProps): react_jsx_runtime0.JSX.Element;
+type PropertyProps = {
+  decl: TSAST.TSDeclaration;
+  children: PropertyFn;
+};
+declare function Property({
+  decl,
+  children
+}: PropertyProps): React$1.ReactNode;
+type DeclarationProps = {
+  decl: TSAST.TSDeclaration;
+};
+declare function Declaration({
+  decl
+}: DeclarationProps): react_jsx_runtime0.JSX.Element | undefined;
+//#endregion
+export { Declaration, DeclarationProps, MethodSignature, MethodSignatureProps, Property, PropertyProps, Type, TypeName, typescript_d_exports as t };

package/dist/languages/typescript.js

@@ -0,0 +1,450 @@
+import { t as __exportAll } from "../chunk-BYypO7fO.js";
+import { useDeclaration, useLanguage, useSpec } from "../contexts/docs.js";
+import "../use-strict-context-L0c8JKg4.js";
+import { useLanguageComponents } from "../contexts/index.js";
+import { useComponents } from "../contexts/use-components.js";
+import style_default from "../style.js";
+import * as React$1 from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/languages/typescript.tsx
+var typescript_exports = /* @__PURE__ */ __exportAll({
+	Declaration: () => Declaration,
+	MethodSignature: () => MethodSignature,
+	Property: () => Property,
+	Type: () => Type,
+	TypeName: () => TypeName
+});
+const ComplexTypes = {
+	TSTypeObject: "object",
+	TSTypeUnion: "union",
+	TSTypeInterface: "interface",
+	TSTypeIntersection: "intersection",
+	TSTypeArray: "array"
+};
+const constStyle = {
+	string: style_default.LiteralString,
+	number: style_default.LiteralNumeric,
+	boolean: style_default.LiteralBoolean
+};
+function Identifier({ name, optional }) {
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
+		className: style_default.TextIdentifier,
+		children: /^[_a-zA-Z][_a-zA-Z0-9]*$/.test(name) ? name : JSON.stringify(name)
+	}), optional && /* @__PURE__ */ jsx("span", {
+		className: style_default.TextPunctuation,
+		children: "?"
+	})] });
+}
+function TypeParams({ params }) {
+	const Lang = useLanguageComponents();
+	const { Join } = useComponents();
+	if (!params?.length) return null;
+	const typeParams = params?.map((param, key) => param.constraint ? /* @__PURE__ */ jsxs(React$1.Fragment, { children: [
+		/* @__PURE__ */ jsx("span", {
+			className: style_default.TypeReference,
+			children: param.name
+		}),
+		/* @__PURE__ */ jsx("span", {
+			className: style_default.TextKeyword,
+			children: "extends "
+		}),
+		/* @__PURE__ */ jsx(Lang.Type, { type: param.constraint })
+	] }, key) : /* @__PURE__ */ jsx(React$1.Fragment, { children: "param.name" }, key));
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx("span", {
+			className: style_default.TypeBracket,
+			children: "<"
+		}),
+		/* @__PURE__ */ jsx(Join, {
+			items: typeParams,
+			limit: 3,
+			children: /* @__PURE__ */ jsx("span", {
+				className: style_default.TextOperator,
+				children: ", "
+			})
+		}),
+		/* @__PURE__ */ jsx("span", {
+			className: style_default.TypeBracket,
+			children: ">"
+		})
+	] });
+}
+function TypePreview({ path }) {
+	const spec = useSpec();
+	const language = useLanguage();
+	const decl = useDeclaration(path, false);
+	const { Join } = useComponents();
+	if (!(decl && "children" in decl && decl.children && decl.children.length > 0) || decl && "type" in decl && decl.type !== void 0 && "kind" in decl["type"] && decl["type"]["kind"] === "TSTypeUnion") return;
+	const items = decl.children.map((prop, key) => {
+		const p = spec?.decls?.[language]?.[prop];
+		return /* @__PURE__ */ jsx("span", {
+			className: style_default.TypePropertyName,
+			children: /* @__PURE__ */ jsx("span", {
+				className: style_default.TextIdentifier,
+				children: p && "key" in p ? p["key"] : null
+			})
+		}, key);
+	});
+	return /* @__PURE__ */ jsxs("span", {
+		className: style_default.TypePreview,
+		"data-stldocs-type-preview": "properties",
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TypeBrace,
+				children: " {"
+			}),
+			/* @__PURE__ */ jsxs("span", {
+				className: style_default.TypePreviewContent,
+				children: [
+					" ",
+					/* @__PURE__ */ jsx(Join, {
+						items,
+						limit: 3,
+						children: /* @__PURE__ */ jsx("span", {
+							className: style_default.TextOperator,
+							children: ", "
+						})
+					}),
+					" "
+				]
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TypeBrace,
+				children: "} "
+			})
+		]
+	});
+}
+function TypeName({ type }) {
+	const Lang = useLanguageComponents();
+	return ComplexTypes[type.kind] ?? /* @__PURE__ */ jsx(Lang.Type, { type });
+}
+function Type({ type }) {
+	const Lang = useLanguageComponents();
+	const { Join, SDKReference } = useComponents();
+	switch (type.kind) {
+		case "TSTypeUnknown":
+		case "TSTypeUndefined":
+		case "TSTypeNever":
+		case "TSTypeVoid":
+		case "TSTypeNull":
+		case "TSTypeAny":
+		case "TSTypeBoolean":
+		case "TSTypeNumber": return /* @__PURE__ */ jsx("span", {
+			className: style_default.Type,
+			children: /* @__PURE__ */ jsx("span", {
+				className: style_default.TypeKeyword,
+				children: type.kind.slice(6).toLowerCase()
+			})
+		});
+		case "TSTypeString": return /* @__PURE__ */ jsx("span", {
+			className: style_default.Type,
+			children: /* @__PURE__ */ jsx("span", {
+				className: style_default.TypeString,
+				children: "string"
+			})
+		});
+		case "TSTypeLiteral": return /* @__PURE__ */ jsx("span", {
+			className: style_default.Type,
+			children: /* @__PURE__ */ jsx("span", {
+				className: constStyle[typeof type.literal],
+				children: JSON.stringify(type.literal)
+			})
+		});
+		case "TSTypeArray": return /* @__PURE__ */ jsxs("span", {
+			className: style_default.Type,
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					className: style_default.TypeArray,
+					children: "Array<"
+				}),
+				/* @__PURE__ */ jsx(Lang.Type, { type: type.elementType }),
+				/* @__PURE__ */ jsx("span", {
+					className: style_default.TypeArray,
+					children: ">"
+				})
+			]
+		});
+		case "TSTypeReference": {
+			const name = type.ident.split(".").at(-1);
+			const params = type.typeParameters?.map((param, key) => /* @__PURE__ */ jsx(Lang.Type, { type: param }, key));
+			return /* @__PURE__ */ jsxs("span", {
+				className: style_default.Type,
+				children: [
+					/* @__PURE__ */ jsx(SDKReference, {
+						stainlessPath: type.$ref,
+						children: name
+					}),
+					params && params.length > 0 && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+						/* @__PURE__ */ jsx("span", {
+							className: style_default.TypeBracket,
+							children: "<"
+						}),
+						/* @__PURE__ */ jsx(Join, {
+							items: params,
+							limit: 3,
+							children: /* @__PURE__ */ jsx("span", {
+								className: style_default.TextOperator,
+								children: ", "
+							})
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: style_default.TypeBracket,
+							children: ">"
+						})
+					] }),
+					/* @__PURE__ */ jsx(TypePreview, { path: type.$ref })
+				]
+			});
+		}
+		case "TSTypeIntersection":
+		case "TSTypeUnion": {
+			const items = type.types.map((t, key) => /* @__PURE__ */ jsx(Lang.Type, { type: t }, key));
+			const delimiter = type.kind === "TSTypeUnion" ? "|" : "&";
+			return /* @__PURE__ */ jsx("span", {
+				className: style_default.Type,
+				children: /* @__PURE__ */ jsx("span", {
+					className: style_default.TypePreview,
+					"data-stldocs-type-preview": "union",
+					children: /* @__PURE__ */ jsx("span", {
+						className: style_default.TypePreviewContent,
+						children: /* @__PURE__ */ jsx(Join, {
+							items,
+							limit: 3,
+							children: /* @__PURE__ */ jsxs("span", {
+								className: style_default.TextOperator,
+								children: [
+									" ",
+									delimiter,
+									" "
+								]
+							})
+						})
+					})
+				})
+			});
+		}
+		case "TSTypeObject":
+		case "TSTypeInterface": {
+			const extend = type.kind === "TSTypeObject" ? null : type.extends?.map((ref, key) => /* @__PURE__ */ jsx(Lang.Type, { type: ref }, key));
+			const items = type.members.map((prop, key) => /* @__PURE__ */ jsxs(React$1.Fragment, { children: [
+				/* @__PURE__ */ jsx("span", {
+					className: style_default.TypePropertyName,
+					children: /* @__PURE__ */ jsx(Identifier, {
+						name: prop.ident,
+						optional: prop.optional
+					})
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: style_default.TextPunctuation,
+					children: ": "
+				}),
+				/* @__PURE__ */ jsx(Lang.Type, { type: prop.type })
+			] }, key));
+			return /* @__PURE__ */ jsxs("span", {
+				className: style_default.Type,
+				children: [extend?.length && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
+					className: style_default.TypeKeyword,
+					children: " extends "
+				}), /* @__PURE__ */ jsx(Join, {
+					items: extend,
+					limit: 3,
+					children: /* @__PURE__ */ jsx("span", {
+						className: style_default.TextOperator,
+						children: ", "
+					})
+				})] }), /* @__PURE__ */ jsxs("span", {
+					className: style_default.TypePreview,
+					"data-stldocs-type-preview": "properties",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: style_default.TypeBrace,
+							children: "{ "
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: style_default.TypePreviewContent,
+							children: /* @__PURE__ */ jsx(Join, {
+								items,
+								limit: 3,
+								children: /* @__PURE__ */ jsx("span", {
+									className: style_default.TextOperator,
+									children: ", "
+								})
+							})
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: style_default.TypeBrace,
+							children: "} "
+						})
+					]
+				})]
+			});
+		}
+	}
+}
+function MethodSignature({ decl }) {
+	const Lang = useLanguageComponents();
+	const { Join, Tooltip } = useComponents();
+	const params = decl.signature.parameters.map((param, i) => /* @__PURE__ */ jsxs(React$1.Fragment, { children: [/* @__PURE__ */ jsx(Tooltip, {
+		content: /* @__PURE__ */ jsx(Lang.Type, { type: param.type }),
+		children: /* @__PURE__ */ jsx("span", {
+			className: style_default.TextIdentifier,
+			children: param.ident
+		})
+	}), param.optional && /* @__PURE__ */ jsx("span", {
+		className: style_default.TextPunctuation,
+		children: "?"
+	})] }, i));
+	return /* @__PURE__ */ jsx("div", {
+		className: style_default.MethodSignature,
+		children: /* @__PURE__ */ jsxs("span", {
+			className: style_default.SignatureTitle,
+			children: [
+				decl.signature.async && /* @__PURE__ */ jsx("span", {
+					className: style_default.TextKeyword,
+					children: "async "
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: style_default.SignatureQualified,
+					children: /* @__PURE__ */ jsx("span", {
+						className: style_default.TextIdentifier,
+						children: decl.qualified?.slice(0, -decl.ident.length)
+					})
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: style_default.SignatureName,
+					children: /* @__PURE__ */ jsx("span", {
+						className: style_default.TextIdentifier,
+						children: decl.ident
+					})
+				}),
+				/* @__PURE__ */ jsxs("span", {
+					className: style_default.MethodSignature,
+					children: [
+						decl.signature.typeParameters && /* @__PURE__ */ jsx(TypeParams, { params: decl.signature.typeParameters }),
+						/* @__PURE__ */ jsx("span", {
+							className: style_default.SignatureParen,
+							children: "("
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: style_default.SignatureParams,
+							children: /* @__PURE__ */ jsx(Join, {
+								items: params,
+								children: /* @__PURE__ */ jsx("span", {
+									className: style_default.TextOperator,
+									children: ", "
+								})
+							})
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: style_default.SignatureParen,
+							children: ")"
+						}),
+						decl.signature.returns && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
+							className: style_default.TextPunctuation,
+							children: ": "
+						}), /* @__PURE__ */ jsx(Lang.Type, { type: decl.signature.returns })] })
+					]
+				})
+			]
+		})
+	});
+}
+function Property({ decl, children }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "TSDeclProperty": return children({
+			name: decl.key,
+			typeName: /* @__PURE__ */ jsx(Lang.TypeName, { type: decl.type }),
+			type: decl.type.kind in ComplexTypes && /* @__PURE__ */ jsx(Lang.Type, { type: decl.type })
+		});
+		case "TSDeclTypeAlias": return children({
+			name: decl.ident,
+			typeName: "alias",
+			type: /* @__PURE__ */ jsx(Lang.Type, { type: decl.type })
+		});
+		case "TSDeclReference": return children({ type: /* @__PURE__ */ jsx(Lang.Type, { type: decl.type }) });
+		case "TSDeclInterface": return children({ type: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TextIdentifier,
+				children: decl.ident
+			}),
+			decl.typeParameters && /* @__PURE__ */ jsx(TypeParams, { params: decl.typeParameters }),
+			decl.extends?.flatMap((t, key) => /* @__PURE__ */ jsxs(React$1.Fragment, { children: [/* @__PURE__ */ jsx("span", {
+				className: style_default.TextKeyword,
+				children: " extends "
+			}), /* @__PURE__ */ jsx(Lang.Type, { type: t })] }, `extends:${key}`))
+		] }) });
+	}
+}
+function Declaration({ decl }) {
+	const Lang = useLanguageComponents();
+	if (!decl) return;
+	switch (decl.kind) {
+		case "TSDeclProperty": return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			decl.declare && /* @__PURE__ */ jsx("span", {
+				className: style_default.TextKeyword,
+				children: "declare "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TypePropertyName,
+				children: /* @__PURE__ */ jsx(Identifier, {
+					name: decl.key,
+					optional: decl.optional
+				})
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TextPunctuation,
+				children: ": "
+			}),
+			/* @__PURE__ */ jsx(Lang.Type, { type: decl.type })
+		] });
+		case "TSDeclFunction": return /* @__PURE__ */ jsx(Lang.MethodSignature, { decl });
+		case "TSDeclTypeAlias": return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(Identifier, { name: decl.ident }),
+			/* @__PURE__ */ jsx(TypeParams, { params: decl.typeParameters }),
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TextOperator,
+				children: " = "
+			}),
+			/* @__PURE__ */ jsx(Lang.Type, { type: decl.type })
+		] });
+		case "TSDeclReference": return /* @__PURE__ */ jsx(Lang.Type, { type: decl.type });
+		case "TSDeclInterface": return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TextIdentifier,
+				children: decl.ident
+			}),
+			/* @__PURE__ */ jsx(TypeParams, { params: decl.typeParameters }),
+			decl.extends?.map((t, index) => /* @__PURE__ */ jsxs(React$1.Fragment, { children: [/* @__PURE__ */ jsx("span", {
+				className: style_default.TextKeyword,
+				children: " extends "
+			}), /* @__PURE__ */ jsx(Lang.Type, { type: t })] }, index)),
+			/* @__PURE__ */ jsx(TypePreview, { path: decl.stainlessPath })
+		] });
+		case "TSDeclClass": return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TextKeyword,
+				children: "class "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: style_default.TextIdentifier,
+				children: decl.ident
+			}),
+			/* @__PURE__ */ jsx(TypeParams, { params: decl.typeParameters }),
+			decl.superClass ? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", {
+				className: style_default.TextKeyword,
+				children: " extends "
+			}), /* @__PURE__ */ jsx(Lang.Type, { type: decl.superClass })] }) : null,
+			decl.implements?.map((t, index) => /* @__PURE__ */ jsxs(React$1.Fragment, { children: [/* @__PURE__ */ jsx("span", {
+				className: style_default.TextKeyword,
+				children: " implements "
+			}), /* @__PURE__ */ jsx(Lang.Type, { type: t })] }, index))
+		] });
+	}
+}
+
+//#endregion
+export { Declaration, MethodSignature, Property, Type, TypeName, typescript_exports as t };

package/dist/markdown/index.d.ts

@@ -0,0 +1,11 @@
+import { d as Method, f as Model, h as Resource, i as DeclarationNode } from "../index-pvh-w1xa.js";
+import { EnvironmentType } from "./utils.js";
+import { t as printer_d_exports } from "./printer.js";
+import { Node } from "@markdoc/markdoc";
+
+//#region src/markdown/index.d.ts
+declare function declaration(env: EnvironmentType, decl: DeclarationNode): Node;
+declare function render(env: EnvironmentType, node: Resource | Method | Model): Node[];
+declare function renderMarkdown(env: EnvironmentType, node: Resource | Method | Model): string;
+//#endregion
+export { declaration, printer_d_exports as printer, render, renderMarkdown };

package/dist/markdown/index.js

@@ -0,0 +1,80 @@
+import "../use-strict-context-L0c8JKg4.js";
+import { code, fence, heading, item, list, paragraph, parse, strong, text } from "./md.js";
+import { getDecl, getSnippet, stripMarkup } from "./utils.js";
+import { declaration as declaration$1, methodSignature, t as printer_exports } from "./printer.js";
+import Markdoc from "@markdoc/markdoc";
+
+//#region src/markdown/index.ts
+function declaration(env, decl) {
+	const content = declaration$1(env.language, decl);
+	return paragraph(code(stripMarkup(content)));
+}
+function renderChildren(env, children, nesting = []) {
+	return list(...children.map((child) => renderDecl(env, child, nesting)));
+}
+function renderDecl(env, path, nesting = []) {
+	const decl = getDecl(env, path);
+	const item$1 = item(declaration(env, decl));
+	const hasChildren = "children" in decl && decl.children && decl.children.length > 0;
+	const showModelProps = !("modelPath" in decl && decl["modelPath"]) || env.options.includeModelProperties;
+	if ("docstring" in decl && decl.docstring) item$1.children.push(...parse(decl.docstring));
+	if (hasChildren && showModelProps && !nesting.includes(path)) item$1.push(renderChildren(env, decl.children ?? [], [...nesting, path]));
+	return item$1;
+}
+function renderMethod(env, method) {
+	const decl = getDecl(env, method.stainlessPath);
+	if (!decl) return [paragraph(text("The method "), code(method.name), text(" is not available in this language."))];
+	const signature = methodSignature(env.language, decl);
+	const [httpMethod, endpoint] = method.endpoint.split(" ");
+	const output = [
+		heading(2, method.title),
+		...env.language === "http" ? [] : [paragraph(code(stripMarkup(signature)))],
+		paragraph(strong(text(httpMethod)), text(" "), code(endpoint))
+	];
+	if (method.description) output.push(...parse(method.description));
+	if (env.language === "http") {
+		const p = "paramsChildren" in decl && typeof decl.paramsChildren === "object" ? decl.paramsChildren : {};
+		for (const [location, value] of Object.entries(p)) {
+			if (value.length < 1) continue;
+			output.push(heading(3, [
+				text(location.at(0)?.toUpperCase() ?? ""),
+				text(location.slice(1)),
+				text(" Parameters")
+			]), renderChildren(env, value));
+		}
+		const bp = "bodyParamsChildren" in decl ? decl.bodyParamsChildren?.["application/json"] : [];
+		if (bp && bp.length > 0) output.push(heading(3, "Body Parameters"), renderChildren(env, bp));
+	}
+	if ("paramsChildren" in decl && Array.isArray(decl.paramsChildren) && decl.paramsChildren.length > 0) output.push(heading(3, "Parameters"), renderChildren(env, decl.paramsChildren));
+	if ("responseChildren" in decl && decl.responseChildren && decl.responseChildren.length > 0) output.push(heading(3, "Returns"), renderChildren(env, decl.responseChildren));
+	const snippet = getSnippet(env, method.stainlessPath);
+	if (snippet) output.push(heading(3, "Example"), fence(env.language, snippet));
+	return output;
+}
+function renderModel(env, model) {
+	return [heading(3, model.title), list(renderDecl(env, `${model.stainlessPath} > (schema)`))];
+}
+function renderResource(env, resource) {
+	const methods = Object.values(resource.methods).filter((method) => getDecl(env, method.stainlessPath)).flatMap((method) => renderMethod(env, method));
+	const models = Object.values(resource.models).filter((model) => getDecl(env, `${model.stainlessPath} > (schema)`)).flatMap((model) => renderModel(env, model));
+	const doc = [heading(1, resource.title), ...methods];
+	if (models.length > 0) doc.push(heading(2, "Domain Types"), ...models);
+	if (!env.options.renderNestedResources) return doc;
+	const children = Object.values(resource.subresources ?? {}).flatMap((resource) => renderResource(env, resource));
+	return [...doc, ...children];
+}
+function render(env, node) {
+	switch (node.kind) {
+		case "resource": return renderResource(env, node);
+		case "http_method": return renderMethod(env, node);
+		case "model": return renderModel(env, node);
+	}
+}
+function renderMarkdown(env, node) {
+	const content = render(env, node);
+	const doc = new Markdoc.Ast.Node("document", {}, content);
+	return Markdoc.format(doc);
+}
+
+//#endregion
+export { declaration, printer_exports as printer, render, renderMarkdown };

package/dist/markdown/md.d.ts

@@ -0,0 +1,15 @@
+import { Node } from "@markdoc/markdoc";
+
+//#region src/markdown/md.d.ts
+declare function heading(level: number, children: string | Node[]): Node;
+declare function text(content: string): Node;
+declare function code(content: string): Node;
+declare function paragraph(...children: Node[]): Node;
+declare function list(...children: Node[]): Node;
+declare function item(...children: Node[]): Node;
+declare function strong(...children: Node[]): Node;
+declare function inline(...children: Node[]): Node;
+declare function fence(language: string, content: string): Node;
+declare function parse(content: string): Node[];
+//#endregion
+export { code, fence, heading, inline, item, list, paragraph, parse, strong, text };

package/dist/markdown/md.js

@@ -0,0 +1,41 @@
+import Markdoc from "@markdoc/markdoc";
+
+//#region src/markdown/md.ts
+function heading(level, children) {
+	const content = inline(...typeof children === "string" ? [text(children)] : children);
+	return new Markdoc.Ast.Node("heading", { level }, [content]);
+}
+function text(content) {
+	return new Markdoc.Ast.Node("text", { content });
+}
+function code(content) {
+	return new Markdoc.Ast.Node("code", { content });
+}
+function paragraph(...children) {
+	const inline = new Markdoc.Ast.Node("inline", {}, children);
+	return new Markdoc.Ast.Node("paragraph", {}, [inline]);
+}
+function list(...children) {
+	return new Markdoc.Ast.Node("list", { ordered: false }, children);
+}
+function item(...children) {
+	return new Markdoc.Ast.Node("item", {}, children);
+}
+function strong(...children) {
+	return new Markdoc.Ast.Node("strong", {}, children);
+}
+function inline(...children) {
+	return new Markdoc.Ast.Node("inline", {}, children);
+}
+function fence(language, content) {
+	return new Markdoc.Ast.Node("fence", {
+		language,
+		content
+	});
+}
+function parse(content) {
+	return Markdoc.parse(content).children;
+}
+
+//#endregion
+export { code, fence, heading, inline, item, list, paragraph, parse, strong, text };

package/dist/markdown/printer.d.ts

@@ -0,0 +1,13 @@
+import { S as Type, i as DeclarationNode } from "../index-pvh-w1xa.js";
+import { DocsLanguage } from "../routing.js";
+
+//#region src/markdown/printer.d.ts
+declare namespace printer_d_exports {
+  export { declaration, methodSignature, type, typeName };
+}
+declare function typeName(language: DocsLanguage, type: Type): string;
+declare function type(language: DocsLanguage, type: Type): string;
+declare function declaration(language: DocsLanguage, decl: DeclarationNode): string;
+declare function methodSignature(language: DocsLanguage, decl: DeclarationNode): string;
+//#endregion
+export { declaration, methodSignature, printer_d_exports as t, type, typeName };